@otto-assistant/bridge 0.4.102 → 0.4.103

package/dist/memory-overview-plugin.js

@@ -18,7 +18,9 @@ function createSessionState() {
     };
 }
 function buildMemoryOverviewReminder({ condensed }) {
-    return `<system-reminder>Project memory from MEMORY.md (condensed table of contents, line numbers shown):\n${condensed}\nOnly headings are shown above — section bodies are hidden. Use Grep to search MEMORY.md for specific topics, or Read with offset and limit to read a section's content. When writing to MEMORY.md, keep titles concise (under 10 words) and content brief (2-3 sentences max). Only track non-obvious learnings that prevent future mistakes and are not already documented in code comments or AGENTS.md. Do not duplicate information that is self-evident from the code.</system-reminder>`;
+    // Trailing newline so this synthetic part does not fuse with the next text
+    // part when the model concatenates message parts.
+    return `<system-reminder>Project memory from MEMORY.md (condensed table of contents, line numbers shown):\n${condensed}\nOnly headings are shown above — section bodies are hidden. Use Grep to search MEMORY.md for specific topics, or Read with offset and limit to read a section's content. When writing to MEMORY.md, keep titles concise (under 10 words) and content brief (2-3 sentences max). Only track non-obvious learnings that prevent future mistakes and are not already documented in code comments or AGENTS.md. Do not duplicate information that is self-evident from the code.</system-reminder>\n`;
 }
 async function freezeMemoryOverview({ directory, state, }) {
     if (state.hasFrozenOverview) {

package/dist/opencode.js

@@ -28,6 +28,7 @@ import { createLogger, LogPrefix } from './logger.js';
 import { notifyError } from './sentry.js';
 import { DirectoryNotAccessibleError, ServerStartError, ServerNotReadyError, FetchError, } from './errors.js';
 import { ensureKimakiCommandShim, getPathEnvKey, getSpawnCommandAndArgs, prependPathEntry, selectResolvedCommand, } from './opencode-command.js';
+import { computeSkillPermission } from './skill-filter.js';
 const opencodeLogger = createLogger(LogPrefix.OPENCODE);
 // Tracks directories that have been initialized, to avoid repeated log spam
 // from the external sync polling loop.
@@ -394,6 +395,13 @@ async function startSingleServer() {
     // OPENCODE_CONFIG_CONTENT was loaded last and overrode user project configs,
     // causing issue #90 (project permissions not being respected).
     const isDev = import.meta.url.endsWith('.ts') || import.meta.url.endsWith('.tsx');
+    // Skill whitelist/blacklist from --enable-skill / --disable-skill CLI flags.
+    // Applied as opencode permission.skill rules so every agent inherits the
+    // filter via Permission.merge(defaults, agentRules, user).
+    const skillPermission = computeSkillPermission({
+        enabledSkills: store.getState().enabledSkills,
+        disabledSkills: store.getState().disabledSkills,
+    });
     const opencodeConfig = {
         $schema: 'https://opencode.ai/config.json',
         lsp: false,
@@ -406,6 +414,7 @@ async function startSingleServer() {
             bash: 'allow',
             external_directory: externalDirectoryPermissions,
             webfetch: 'allow',
+            ...(skillPermission && { skill: skillPermission }),
         },
         agent: {
             explore: {

package/dist/queue-question-select-drain.e2e.test.js

@@ -22,6 +22,22 @@ async function waitForPendingQuestion({ threadId, timeoutMs, }) {
     }
     throw new Error('Timed out waiting for pending question context');
 }
+async function expectNoBotMessageContaining({ discord, threadId, text, timeout, }) {
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+        const messages = await discord.thread(threadId).getMessages();
+        const match = messages.find((message) => {
+            return (message.author.id === discord.botUserId
+                && message.content.includes(text));
+        });
+        if (match) {
+            throw new Error(`Unexpected bot message containing ${JSON.stringify(text)} while it should still be queued`);
+        }
+        await new Promise((resolve) => {
+            setTimeout(resolve, 20);
+        });
+    }
+}
 describe('queue drain after question select answer', () => {
     const ctx = setupQueueAdvancedSuite({
         channelId: TEXT_CHANNEL_ID,
@@ -52,16 +68,10 @@ describe('queue drain after question select answer', () => {
         });
         // Get the pending question context hash from the internal map.
         // By this point the question message is visible so the context must exist.
-        const pending = (() => {
-            const entry = [...pendingQuestionContexts.entries()].find(([, context]) => {
-                return context.thread.id === thread.id;
-            });
-            return entry ? { contextHash: entry[0] } : null;
-        })();
-        expect(pending).toBeTruthy();
-        if (!pending) {
-            throw new Error('Expected pending question context');
-        }
+        const pending = await waitForPendingQuestion({
+            threadId: thread.id,
+            timeoutMs: 8_000,
+        });
         const questionMsg = questionMessages.find((m) => {
             return m.content.includes('How to proceed?');
         });
@@ -117,4 +127,119 @@ describe('queue drain after question select answer', () => {
         expect(timeline).toContain('⬥ ok');
         expect(timeline).toContain('*project ⋅ main ⋅');
     }, 20_000);
+    test('only the first queued message is handed off after dropdown answer', async () => {
+        const marker = 'QUESTION_SELECT_QUEUE_MARKER second-test';
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: marker,
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 8_000,
+            predicate: (t) => {
+                return t.name === marker;
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        const questionMessages = await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            text: 'How to proceed?',
+            timeout: 12_000,
+        });
+        const pending = await waitForPendingQuestion({
+            threadId: thread.id,
+            timeoutMs: 8_000,
+        });
+        const questionMsg = questionMessages.find((message) => {
+            return message.content.includes('How to proceed?');
+        });
+        expect(questionMsg).toBeTruthy();
+        if (!questionMsg) {
+            throw new Error('Expected question message');
+        }
+        const firstQueuedPrompt = 'SLOW_ABORT_MARKER run long response';
+        const secondQueuedPrompt = 'Reply with exactly: post-question-second';
+        const { id: firstQueueInteractionId } = await th.user(TEST_USER_ID)
+            .runSlashCommand({
+            name: 'queue',
+            options: [{ name: 'message', type: 3, value: firstQueuedPrompt }],
+        });
+        await th.waitForInteractionAck({
+            interactionId: firstQueueInteractionId,
+            timeout: 8_000,
+        });
+        const { id: secondQueueInteractionId } = await th.user(TEST_USER_ID)
+            .runSlashCommand({
+            name: 'queue',
+            options: [{ name: 'message', type: 3, value: secondQueuedPrompt }],
+        });
+        await th.waitForInteractionAck({
+            interactionId: secondQueueInteractionId,
+            timeout: 8_000,
+        });
+        const interaction = await th.user(TEST_USER_ID).selectMenu({
+            messageId: questionMsg.id,
+            customId: `ask_question:${pending.contextHash}:0`,
+            values: ['0'],
+        });
+        await th.waitForInteractionAck({
+            interactionId: interaction.id,
+            timeout: 8_000,
+        });
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            text: `» **question-select-tester:** ${firstQueuedPrompt}`,
+            timeout: 8_000,
+        });
+        await expectNoBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            text: `» **question-select-tester:** ${secondQueuedPrompt}`,
+            timeout: 200,
+        });
+        await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 8_000,
+            afterMessageIncludes: `» **question-select-tester:** ${firstQueuedPrompt}`,
+            afterAuthorId: ctx.discord.botUserId,
+        });
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            text: `» **question-select-tester:** ${secondQueuedPrompt}`,
+            timeout: 8_000,
+        });
+        await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 8_000,
+            afterMessageIncludes: `» **question-select-tester:** ${secondQueuedPrompt}`,
+            afterAuthorId: ctx.discord.botUserId,
+        });
+        const timeline = await th.text({ showInteractions: true });
+        expect(timeline).toMatchInlineSnapshot(`
+        "--- from: user (question-select-tester)
+        QUESTION_SELECT_QUEUE_MARKER second-test
+        --- from: assistant (TestBot)
+        **Select action**
+        How to proceed?
+        ✓ _Alpha_
+        [user interaction]
+        Queued message (position 1)
+        [user interaction]
+        Queued message (position 2)
+        [user selects dropdown: 0]
+        » **question-select-tester:** SLOW_ABORT_MARKER run long response
+        ⬥ slow-response-started
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        » **question-select-tester:** Reply with exactly: post-question-second
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+      `);
+        expect(timeline).toContain(`» **question-select-tester:** ${firstQueuedPrompt}`);
+        expect(timeline).toContain('⬥ slow-response-started');
+        expect(timeline).toContain(`» **question-select-tester:** ${secondQueuedPrompt}`);
+        expect(timeline).toContain('⬥ ok');
+    }, 20_000);
 });

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

@@ -95,6 +95,33 @@ export function dequeueItem(threadId) {
 export function clearQueueItems(threadId) {
     updateThread(threadId, (t) => ({ ...t, queueItems: [] }));
 }
+export function removeQueueItemAtPosition(threadId, position) {
+    if (position < 1) {
+        return undefined;
+    }
+    let removedItem;
+    store.setState((s) => {
+        const t = s.threads.get(threadId);
+        if (!t) {
+            return s;
+        }
+        const index = position - 1;
+        const removed = t.queueItems[index];
+        if (!removed) {
+            return s;
+        }
+        removedItem = removed;
+        const newThreads = new Map(s.threads);
+        newThreads.set(threadId, {
+            ...t,
+            queueItems: t.queueItems.filter((_, itemIndex) => {
+                return itemIndex !== index;
+            }),
+        });
+        return { threads: newThreads };
+    });
+    return removedItem;
+}
 // ── Queries ──────────────────────────────────────────────────────
 export function getThreadState(threadId) {
     return store.getState().threads.get(threadId);

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

@@ -238,11 +238,13 @@ export function isEssentialToolPart(part) {
 // ── Thread title derivation ──────────────────────────────────────
 const DISCORD_THREAD_NAME_MAX = 100;
 const WORKTREE_THREAD_PREFIX = '⬦ ';
-// Pure derivation: given an OpenCode session title and the current thread name,
-// return the new thread name to apply, or undefined when no rename is needed.
-// - Skips placeholder titles ("New Session - ...") to match external-sync.
-// - Preserves worktree prefix when the current name carries it.
-// - Returns undefined when the candidate matches currentName already.
+// Prefixes that should survive OpenCode session title renames.
+// When a thread starts with one of these, the rename preserves it.
+const PRESERVED_THREAD_PREFIXES = [
+    WORKTREE_THREAD_PREFIX,
+    'btw: ',
+    'Fork: ',
+];
 export function deriveThreadNameFromSessionTitle({ sessionTitle, currentName, }) {
     const trimmed = sessionTitle?.trim();
     if (!trimmed) {
@@ -251,9 +253,10 @@ export function deriveThreadNameFromSessionTitle({ sessionTitle, currentName, })
     if (/^new session\s*-/i.test(trimmed)) {
         return undefined;
     }
-    const hasWorktreePrefix = currentName.startsWith(WORKTREE_THREAD_PREFIX);
-    const prefix = hasWorktreePrefix ? WORKTREE_THREAD_PREFIX : '';
-    const candidate = `${prefix}${trimmed}`.slice(0, DISCORD_THREAD_NAME_MAX);
+    const matchedPrefix = PRESERVED_THREAD_PREFIXES.find((p) => {
+        return currentName.startsWith(p);
+    }) ?? '';
+    const candidate = `${matchedPrefix}${trimmed}`.slice(0, DISCORD_THREAD_NAME_MAX);
     if (candidate === currentName) {
         return undefined;
     }
@@ -1493,6 +1496,7 @@ export class ThreadSessionRuntime {
         await this.handleMainPart(part);
     }
     async handleMainPart(part) {
+        const sessionId = this.state?.sessionId;
         if (part.type === 'step-start') {
             this.ensureTypingNow();
             return;
@@ -1506,13 +1510,36 @@ export class ThreadSessionRuntime {
             await this.sendPartMessage({ part });
             // Track task tool spawning subtask sessions
             if (part.tool === 'task' && !this.state?.sentPartIds.has(part.id)) {
-                const description = part.state.input?.description || '';
-                const agent = part.state.input?.subagent_type || 'task';
-                const childSessionId = part.state.metadata?.sessionId || '';
+                const description = typeof part.state.input?.description === 'string'
+                    ? part.state.input.description
+                    : '';
+                const agent = typeof part.state.input?.subagent_type === 'string'
+                    ? part.state.input.subagent_type
+                    : 'task';
+                const childSessionId = typeof part.state.metadata?.sessionId === 'string'
+                    ? part.state.metadata.sessionId
+                    : '';
                 if (description && childSessionId) {
                     if ((await this.getVerbosity()) !== 'text_only') {
                         const taskDisplay = `┣ ${agent} **${description}**`;
-                        await sendThreadMessage(this.thread, taskDisplay + '\n\n');
+                        threadState.updateThread(this.threadId, (t) => {
+                            const newIds = new Set(t.sentPartIds);
+                            newIds.add(part.id);
+                            return { ...t, sentPartIds: newIds };
+                        });
+                        const sendResult = await errore.tryAsync(() => {
+                            return sendThreadMessage(this.thread, taskDisplay + '\n\n');
+                        });
+                        if (sendResult instanceof Error) {
+                            threadState.updateThread(this.threadId, (t) => {
+                                const newIds = new Set(t.sentPartIds);
+                                newIds.delete(part.id);
+                                return { ...t, sentPartIds: newIds };
+                            });
+                            discordLogger.error(`ERROR: Failed to send task part ${part.id}:`, sendResult);
+                            return;
+                        }
+                        await setPartMessage(part.id, sendResult.id, this.thread.id);
                     }
                 }
             }
@@ -1899,8 +1926,9 @@ export class ThreadSessionRuntime {
         this.onInteractiveUiStateChanged();
         // When a question is answered and the local queue has items, the model may
         // continue the same run without ever reaching the local-queue idle gate.
-        // Hand the queued items to OpenCode's own prompt queue immediately instead
-        // of waiting for tryDrainQueue() to see an idle session.
+        // Hand off only the next queued item to OpenCode immediately so the queue
+        // resumes, but keep later items local so their `» user:` indicators still
+        // appear one-by-one when they actually become active.
         if (this.getQueueLength() > 0 && !this.questionReplyQueueHandoffPromise) {
             logger.log(`[QUESTION REPLIED] Queue has ${this.getQueueLength()} items, handing off to opencode queue`);
             this.questionReplyQueueHandoffPromise = this.handoffQueuedItemsAfterQuestionReply({
@@ -1916,8 +1944,8 @@ export class ThreadSessionRuntime {
         }
     }
     // Detached helper promise for the "question answered while local queue has
-    // items" flow. Prevents starting two overlapping local->opencode queue
-    // handoff sequences when multiple question replies land close together.
+    // items" flow. Prevents starting two overlapping single-item handoffs when
+    // multiple question replies land close together.
     questionReplyQueueHandoffPromise = null;
     async handoffQueuedItemsAfterQuestionReply({ sessionId, }) {
         if (this.listenerAborted) {
@@ -1927,19 +1955,17 @@ export class ThreadSessionRuntime {
             logger.log(`[QUESTION REPLIED] Session changed before queue handoff for thread ${this.threadId}`);
             return;
         }
-        while (this.state?.sessionId === sessionId) {
-            const next = threadState.dequeueItem(this.threadId);
-            if (!next) {
-                return;
-            }
-            const displayText = next.command
-                ? `/${next.command.name}`
-                : `${next.prompt.slice(0, 150)}${next.prompt.length > 150 ? '...' : ''}`;
-            if (displayText.trim()) {
-                await sendThreadMessage(this.thread, `» **${next.username}:** ${displayText}`);
-            }
-            await this.submitViaOpencodeQueue(next);
+        const next = threadState.dequeueItem(this.threadId);
+        if (!next) {
+            return;
         }
+        const displayText = next.command
+            ? `/${next.command.name}`
+            : `${next.prompt.slice(0, 150)}${next.prompt.length > 150 ? '...' : ''}`;
+        if (displayText.trim()) {
+            await sendThreadMessage(this.thread, `» **${next.username}:** ${displayText}`);
+        }
+        await this.submitViaOpencodeQueue(next);
     }
     async handleSessionStatus(properties) {
         const sessionId = this.state?.sessionId;
@@ -2556,6 +2582,10 @@ export class ThreadSessionRuntime {
     clearQueue() {
         threadState.clearQueueItems(this.threadId);
     }
+    /** Remove a queued message by its 1-based position. */
+    removeQueuePosition(position) {
+        return threadState.removeQueueItemAtPosition(this.threadId, position);
+    }
     // ── Queue Drain ─────────────────────────────────────────────
     /**
      * Check if we can dispatch the next queued message. If so, dequeue and

package/dist/session-title-rename.test.js

@@ -67,6 +67,18 @@ describe('deriveThreadNameFromSessionTitle', () => {
             currentName: 'seed',
         })).toMatchInlineSnapshot(`undefined`);
     });
+    test('preserves btw: prefix from current name', () => {
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: 'Side question about auth',
+            currentName: 'btw: why is auth broken',
+        })).toMatchInlineSnapshot(`"btw: Side question about auth"`);
+    });
+    test('preserves Fork: prefix from current name', () => {
+        expect(deriveThreadNameFromSessionTitle({
+            sessionTitle: 'Forked task title',
+            currentName: 'Fork: old session title',
+        })).toMatchInlineSnapshot(`"Fork: Forked task title"`);
+    });
     test('returns undefined for null/undefined title', () => {
         expect(deriveThreadNameFromSessionTitle({
             sessionTitle: null,

package/dist/skill-filter.js

@@ -0,0 +1,31 @@
+// Computes opencode permission.skill rules from kimaki's --enable-skill /
+// --disable-skill CLI flags.
+//
+// OpenCode filters skills available to the model via
+// Permission.evaluate("skill", skill.name, agent.permission). We inject a
+// top-level permission.skill ruleset into the generated opencode-config.json
+// so every agent inherits the same whitelist/blacklist via Permission.merge.
+//
+// Whitelist mode: { '*': 'deny', 'name': 'allow', ... }
+// Blacklist mode: { 'name': 'deny', ... }
+// Neither set:    undefined (skills are unfiltered)
+//
+// cli.ts validates mutual exclusion of the two flags at startup, so this
+// helper assumes at most one of the two arrays is non-empty.
+export function computeSkillPermission({ enabledSkills, disabledSkills, }) {
+    if (enabledSkills.length > 0) {
+        const rules = { '*': 'deny' };
+        for (const name of enabledSkills) {
+            rules[name] = 'allow';
+        }
+        return rules;
+    }
+    if (disabledSkills.length > 0) {
+        const rules = {};
+        for (const name of disabledSkills) {
+            rules[name] = 'deny';
+        }
+        return rules;
+    }
+    return undefined;
+}

package/dist/skill-filter.test.js

@@ -0,0 +1,65 @@
+import { describe, test, expect } from 'vitest';
+import { computeSkillPermission } from './skill-filter.js';
+describe('computeSkillPermission', () => {
+    test('empty inputs returns undefined (no filtering)', () => {
+        expect(computeSkillPermission({ enabledSkills: [], disabledSkills: [] })).toMatchInlineSnapshot(`undefined`);
+    });
+    test('whitelist single skill', () => {
+        expect(computeSkillPermission({
+            enabledSkills: ['npm-package'],
+            disabledSkills: [],
+        })).toMatchInlineSnapshot(`
+      {
+        "*": "deny",
+        "npm-package": "allow",
+      }
+    `);
+    });
+    test('whitelist multiple skills', () => {
+        expect(computeSkillPermission({
+            enabledSkills: ['npm-package', 'playwriter', 'errore'],
+            disabledSkills: [],
+        })).toMatchInlineSnapshot(`
+      {
+        "*": "deny",
+        "errore": "allow",
+        "npm-package": "allow",
+        "playwriter": "allow",
+      }
+    `);
+    });
+    test('blacklist single skill', () => {
+        expect(computeSkillPermission({
+            enabledSkills: [],
+            disabledSkills: ['jitter'],
+        })).toMatchInlineSnapshot(`
+      {
+        "jitter": "deny",
+      }
+    `);
+    });
+    test('blacklist multiple skills', () => {
+        expect(computeSkillPermission({
+            enabledSkills: [],
+            disabledSkills: ['jitter', 'termcast'],
+        })).toMatchInlineSnapshot(`
+      {
+        "jitter": "deny",
+        "termcast": "deny",
+      }
+    `);
+    });
+    test('whitelist takes precedence when both are set (cli.ts is expected to reject this upstream)', () => {
+        // cli.ts validates mutual exclusion before reaching this helper. This
+        // test documents the defensive behavior if both arrays ever leak through.
+        expect(computeSkillPermission({
+            enabledSkills: ['npm-package'],
+            disabledSkills: ['jitter'],
+        })).toMatchInlineSnapshot(`
+      {
+        "*": "deny",
+        "npm-package": "allow",
+      }
+    `);
+    });
+});

package/dist/store.js

@@ -9,6 +9,8 @@ export const store = createStore(() => ({
     defaultVerbosity: 'text_and_essential_tools',
     defaultMentionMode: false,
     critiqueEnabled: true,
+    enabledSkills: [],
+    disabledSkills: [],
     discordBaseUrl: 'https://discord.com',
     gatewayToken: null,
     registeredUserCommands: [],

package/dist/system-message.js

@@ -236,11 +236,17 @@ ${escapePromptText(repliedMessage.text)}
             : []),
         ...(worktree && worktreeChanged
             ? [
-                `<system-reminder>\nThis session is running inside a git worktree.\n- Worktree path: ${worktree.worktreeDirectory}\n- Branch: ${worktree.branch}\n- Main repo: ${worktree.mainRepoDirectory}\nRun checks in this worktree. Do not create another worktree by default. Ask before merging changes back to the main branch.\n</system-reminder>`,
+                `<system-reminder>\nThis session is running inside a git worktree. The working directory (cwd / pwd) has changed. The user expects you to edit files in the new cwd. You MUST operate inside the new worktree from now on.\n- New worktree path (new cwd / pwd, edit files here): ${worktree.worktreeDirectory}\n- Branch: ${worktree.branch}\n- Main repo path (previous folder, DO NOT TOUCH): ${worktree.mainRepoDirectory}\nYou MUST read, write, and edit files only under the new worktree path ${worktree.worktreeDirectory}. You MUST NOT read, write, or edit any files under the main repo path ${worktree.mainRepoDirectory} — even though it is the same project, that folder is a separate checkout and the user or another agent may be actively working there, so writing to it would override their unrelated changes. Run all checks (tests, builds, lint) inside the new worktree. Do not create another worktree by default. Ask before merging changes back to the main branch.\n</system-reminder>`,
             ]
             : []),
     ];
-    return sections.join('\n\n');
+    if (sections.length === 0) {
+        return '';
+    }
+    // Always end synthetic context with a trailing newline so it does not fuse
+    // with the next text part (for example the user's actual prompt) when the
+    // model concatenates message parts.
+    return `${sections.join('\n\n')}\n`;
 }
 export function getOpencodeSystemMessage({ sessionId, channelId, guildId, threadId, channelTopic, agents, username, }) {
     const userArg = ` --user ${JSON.stringify(username || 'username')}`;
@@ -266,7 +272,7 @@ This is required to distinguish essential bash calls from read-only ones in low-
 
 Your current OpenCode session ID is: ${sessionId}${channelId ? `\nYour current Discord channel ID is: ${channelId}` : ''}${threadId ? `\nYour current Discord thread ID is: ${threadId}` : ''}${guildId ? `\nYour current Discord guild ID is: ${guildId}` : ''}
 
-Per-turn Discord metadata like the current user and current agent is delivered in synthetic user message parts. Worktree reminders are emitted only when the worktree changes.
+Per-turn Discord metadata like the current user and current agent is delivered in synthetic user message parts.
 
 ## permissions
 
@@ -414,6 +420,8 @@ Notification strategy for scheduled tasks:
 - Replace \`@username\` with the relevant user from the current thread context.
 - Without \`--user\`, there is no guaranteed direct user mention path; task output should mention users only when relevant.
 - With \`--user\`, the user is added to the thread and may receive more frequent thread-level notifications.
+- If a scheduled task completes with no actionable result and no user-visible change, prefer archiving the session after the final message so Discord does not keep a no-op thread highlighted.
+- Example no-op cleanup command: \`kimaki session archive --session ${sessionId}\`
 
 Manage scheduled tasks with:
 
@@ -429,6 +437,7 @@ Use case patterns:
 - Weekly QA: schedule "run full test suite, inspect failures, post summary, and mention @username only when failures require review".
 - Weekly benchmark automation: schedule a benchmark prompt that runs model evals, writes JSON outputs in the repo, commits results, and mentions only for regressions.
 - Recurring maintenance: use cron \`--send-at\` for repetitive tasks like rotating secrets, checking dependency updates, running security audits, or cleaning up stale branches. Example: \`--send-at "0 9 1 * *"\` to run on the 1st of every month.
+- Quiet no-op checks: if a recurring task checks something and finds nothing to report, let it post a brief final summary and then archive the session with \`kimaki session archive --session ${sessionId}\`. Example: a scheduled email triage run that finds no new emails should archive itself so it does not add noise to Discord.
 - Thread reminders: when the user says "remind me about this in 2 hours" (or any duration), use \`--send-at\` with \`--thread\` to resurface the current thread. Compute the future UTC time and send a mention so Discord shows a notification:
 
 kimaki send --session ${sessionId} --prompt "Reminder: <@USER_ID> you asked to be reminded about this thread." --send-at "<future_UTC_time>" --notify-only --agent <current_agent>

package/dist/system-message.test.js

@@ -30,7 +30,7 @@ describe('system-message', () => {
       Your current Discord thread ID is: thread_123
       Your current Discord guild ID is: guild_123
 
-      Per-turn Discord metadata like the current user and current agent is delivered in synthetic user message parts. Worktree reminders are emitted only when the worktree changes.
+      Per-turn Discord metadata like the current user and current agent is delivered in synthetic user message parts.
 
       ## permissions
 
@@ -181,6 +181,8 @@ describe('system-message', () => {
       - Replace \`@username\` with the relevant user from the current thread context.
       - Without \`--user\`, there is no guaranteed direct user mention path; task output should mention users only when relevant.
       - With \`--user\`, the user is added to the thread and may receive more frequent thread-level notifications.
+      - If a scheduled task completes with no actionable result and no user-visible change, prefer archiving the session after the final message so Discord does not keep a no-op thread highlighted.
+      - Example no-op cleanup command: \`kimaki session archive --session ses_123\`
 
       Manage scheduled tasks with:
 
@@ -196,6 +198,7 @@ describe('system-message', () => {
       - Weekly QA: schedule "run full test suite, inspect failures, post summary, and mention @username only when failures require review".
       - Weekly benchmark automation: schedule a benchmark prompt that runs model evals, writes JSON outputs in the repo, commits results, and mentions only for regressions.
       - Recurring maintenance: use cron \`--send-at\` for repetitive tasks like rotating secrets, checking dependency updates, running security audits, or cleaning up stale branches. Example: \`--send-at "0 9 1 * *"\` to run on the 1st of every month.
+      - Quiet no-op checks: if a recurring task checks something and finds nothing to report, let it post a brief final summary and then archive the session with \`kimaki session archive --session ses_123\`. Example: a scheduled email triage run that finds no new emails should archive itself so it does not add noise to Discord.
       - Thread reminders: when the user says "remind me about this in 2 hours" (or any duration), use \`--send-at\` with \`--thread\` to resurface the current thread. Compute the future UTC time and send a mention so Discord shows a notification:
 
       kimaki send --session ses_123 --prompt "Reminder: <@USER_ID> you asked to be reminded about this thread." --send-at "<future_UTC_time>" --notify-only --agent <current_agent>
@@ -605,12 +608,13 @@ describe('system-message', () => {
       </system-reminder>
 
       <system-reminder>
-      This session is running inside a git worktree.
-      - Worktree path: /repo/.worktrees/prompt-cache
+      This session is running inside a git worktree. The working directory (cwd / pwd) has changed. The user expects you to edit files in the new cwd. You MUST operate inside the new worktree from now on.
+      - New worktree path (new cwd / pwd, edit files here): /repo/.worktrees/prompt-cache
       - Branch: prompt-cache
-      - Main repo: /repo
-      Run checks in this worktree. Do not create another worktree by default. Ask before merging changes back to the main branch.
-      </system-reminder>"
+      - Main repo path (previous folder, DO NOT TOUCH): /repo
+      You MUST read, write, and edit files only under the new worktree path /repo/.worktrees/prompt-cache. You MUST NOT read, write, or edit any files under the main repo path /repo — even though it is the same project, that folder is a separate checkout and the user or another agent may be actively working there, so writing to it would override their unrelated changes. Run all checks (tests, builds, lint) inside the new worktree. Do not create another worktree by default. Ask before merging changes back to the main branch.
+      </system-reminder>
+      "
     `);
     });
 });