kimaki 0.30.0 → 0.30.1

package/dist/session-handler/event-stream-state.test.js

@@ -1542,12 +1542,107 @@ describe('getPromptCacheClear', () => {
             sessionId,
             currentMessageId: 'msg_asst_2',
         })).toEqual({
-            previousCacheRead: 20000,
+            expectedCacheRead: 20000,
             currentCacheRead: 0,
             previousMessageId: 'msg_asst_1',
             currentMessageId: 'msg_asst_2',
         });
     });
+    test('detects a miss on the second turn when the first turn only wrote cache', () => {
+        const sessionId = 'ses_cache_second_turn';
+        const events = [
+            userEvent({ sessionId, messageId: 'msg_user_1', created: 1 }),
+            assistantEvent({
+                sessionId,
+                messageId: 'msg_asst_1',
+                parentID: 'msg_user_1',
+                created: 2,
+                tokens: {
+                    input: 100,
+                    output: 10,
+                    reasoning: 0,
+                    cache: { read: 0, write: 20000 },
+                },
+            }),
+            userEvent({ sessionId, messageId: 'msg_user_2', created: 3 }),
+            assistantEvent({
+                sessionId,
+                messageId: 'msg_asst_2',
+                parentID: 'msg_user_2',
+                created: 4,
+                tokens: {
+                    input: 100,
+                    output: 12,
+                    reasoning: 0,
+                    cache: { read: 0, write: 20200 },
+                },
+            }),
+        ];
+        expect(getPromptCacheClear({
+            events,
+            sessionId,
+            currentMessageId: 'msg_asst_2',
+        })).toEqual({
+            expectedCacheRead: 20000,
+            currentCacheRead: 0,
+            previousMessageId: 'msg_asst_1',
+            currentMessageId: 'msg_asst_2',
+        });
+    });
+    test('detects consecutive misses, not only every other turn', () => {
+        const sessionId = 'ses_cache_consecutive';
+        const events = [
+            userEvent({ sessionId, messageId: 'msg_user_1', created: 1 }),
+            assistantEvent({
+                sessionId,
+                messageId: 'msg_asst_1',
+                parentID: 'msg_user_1',
+                created: 2,
+                tokens: {
+                    input: 100,
+                    output: 10,
+                    reasoning: 0,
+                    cache: { read: 20000, write: 100 },
+                },
+            }),
+            userEvent({ sessionId, messageId: 'msg_user_2', created: 3 }),
+            assistantEvent({
+                sessionId,
+                messageId: 'msg_asst_2',
+                parentID: 'msg_user_2',
+                created: 4,
+                tokens: {
+                    input: 100,
+                    output: 10,
+                    reasoning: 0,
+                    cache: { read: 0, write: 20300 },
+                },
+            }),
+            userEvent({ sessionId, messageId: 'msg_user_3', created: 5 }),
+            assistantEvent({
+                sessionId,
+                messageId: 'msg_asst_3',
+                parentID: 'msg_user_3',
+                created: 6,
+                tokens: {
+                    input: 100,
+                    output: 10,
+                    reasoning: 0,
+                    cache: { read: 0, write: 20500 },
+                },
+            }),
+        ];
+        expect(getPromptCacheClear({
+            events,
+            sessionId,
+            currentMessageId: 'msg_asst_3',
+        })).toEqual({
+            expectedCacheRead: 20300,
+            currentCacheRead: 0,
+            previousMessageId: 'msg_asst_2',
+            currentMessageId: 'msg_asst_3',
+        });
+    });
     test('detects a cache drop when prompt size stays similar', () => {
         const sessionId = 'ses_cache_drop';
         const events = [
@@ -1583,7 +1678,7 @@ describe('getPromptCacheClear', () => {
             sessionId,
             currentMessageId: 'msg_asst_2',
         })).toEqual({
-            previousCacheRead: 40000,
+            expectedCacheRead: 40000,
             currentCacheRead: 8000,
             previousMessageId: 'msg_asst_1',
             currentMessageId: 'msg_asst_2',
@@ -1679,8 +1774,8 @@ describe('getPromptCacheClear', () => {
             currentMessageId: 'msg_asst_2',
         })).toBeUndefined();
     });
-    test('ignores a smaller prompt after context reduction', () => {
-        const sessionId = 'ses_cache_smaller';
+    test('ignores a smaller prompt that is still read from cache after a revert', () => {
+        const sessionId = 'ses_cache_revert';
         const events = [
             userEvent({ sessionId, messageId: 'msg_user_1', created: 1 }),
             assistantEvent({
@@ -1702,10 +1797,10 @@ describe('getPromptCacheClear', () => {
                 parentID: 'msg_user_2',
                 created: 4,
                 tokens: {
-                    input: 5000,
+                    input: 200,
                     output: 10,
                     reasoning: 0,
-                    cache: { read: 8000, write: 5000 },
+                    cache: { read: 8000, write: 0 },
                 },
             }),
         ];
@@ -1715,6 +1810,47 @@ describe('getPromptCacheClear', () => {
             currentMessageId: 'msg_asst_2',
         })).toBeUndefined();
     });
+    test('detects a miss when the prompt shrank without pruning', () => {
+        const sessionId = 'ses_cache_shrunk_miss';
+        const events = [
+            userEvent({ sessionId, messageId: 'msg_user_1', created: 1 }),
+            assistantEvent({
+                sessionId,
+                messageId: 'msg_asst_1',
+                parentID: 'msg_user_1',
+                created: 2,
+                tokens: {
+                    input: 100,
+                    output: 10,
+                    reasoning: 0,
+                    cache: { read: 187000, write: 0 },
+                },
+            }),
+            userEvent({ sessionId, messageId: 'msg_user_2', created: 3 }),
+            assistantEvent({
+                sessionId,
+                messageId: 'msg_asst_2',
+                parentID: 'msg_user_2',
+                created: 4,
+                tokens: {
+                    input: 182000,
+                    output: 10,
+                    reasoning: 0,
+                    cache: { read: 0, write: 0 },
+                },
+            }),
+        ];
+        expect(getPromptCacheClear({
+            events,
+            sessionId,
+            currentMessageId: 'msg_asst_2',
+        })).toEqual({
+            expectedCacheRead: 182000,
+            currentCacheRead: 0,
+            previousMessageId: 'msg_asst_1',
+            currentMessageId: 'msg_asst_2',
+        });
+    });
     test('compares against the previous user turn, not a same-turn tool step', () => {
         const sessionId = 'ses_cache_same_turn';
         const events = [
@@ -1762,7 +1898,7 @@ describe('getPromptCacheClear', () => {
             sessionId,
             currentMessageId: 'msg_asst_2b',
         })).toEqual({
-            previousCacheRead: 20000,
+            expectedCacheRead: 20000,
             currentCacheRead: 0,
             previousMessageId: 'msg_asst_1',
             currentMessageId: 'msg_asst_2b',
@@ -1804,7 +1940,7 @@ describe('getPromptCacheClear', () => {
             currentMessageId: 'msg_asst_2',
         })).toBeUndefined();
     });
-    test('does not compare across an aborted assistant', () => {
+    test('compares across an aborted assistant with the last good reply', () => {
         const sessionId = 'ses_cache_abort_bridge';
         const events = [
             userEvent({ sessionId, messageId: 'msg_user_1', created: 1 }),
@@ -1852,7 +1988,12 @@ describe('getPromptCacheClear', () => {
             events,
             sessionId,
             currentMessageId: 'msg_asst_3',
-        })).toBeUndefined();
+        })).toEqual({
+            expectedCacheRead: 40000,
+            currentCacheRead: 0,
+            previousMessageId: 'msg_asst_1',
+            currentMessageId: 'msg_asst_3',
+        });
     });
     test('does not compare across a compaction summary', () => {
         const sessionId = 'ses_cache_compaction';
@@ -1993,13 +2134,13 @@ describe('getPromptCacheClear', () => {
     });
     test('formats a compact cache-miss notice', () => {
         expect(formatPromptCacheClearMessage({
-            previousCacheRead: 20000,
+            expectedCacheRead: 20000,
             currentCacheRead: 0,
             previousMessageId: 'msg_asst_1',
             currentMessageId: 'msg_asst_2',
         })).toBe('prompt cache missed (20k → 0)');
         expect(formatPromptCacheClearMessage({
-            previousCacheRead: 20000,
+            expectedCacheRead: 20000,
             currentCacheRead: 0,
             previousMessageId: 'msg_asst_1',
             currentMessageId: 'msg_asst_2',

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

@@ -17,7 +17,7 @@ import { isAbortError } from '../utils.js';
 import { registerEventListener, unregisterEventListener, waitForGlobalEventListener, } from './global-event-listener.js';
 import { createLogger, LogPrefix } from '../logger.js';
 import { sendThreadMessage, sendSessionPartMessage, SILENT_MESSAGE_FLAGS, NOTIFY_MESSAGE_FLAGS, raceDiscordRename, DISCORD_THREAD_RENAME_TIMEOUT_MS, resolveThreadFooterMentionUserId, resolveWorkingDirectory, } from '../discord-utils.js';
-import { asDiscordQuote, asSystemLine, formatPart, formatTaskToolTitle, planAssistantTurnFlush, QUEUE_PREFIX, sessionPartContent, sessionPartKind, shouldLeadWithBlankLine, shouldQuoteIntermediateTextPart, STATUS_PREFIX, WORKTREE_PREFIX, } from '../message-formatting.js';
+import { asDiscordQuote, asSubtext, formatPart, formatTaskToolTitle, planAssistantTurnFlush, QUEUE_PREFIX, sessionPartContent, sessionPartKind, shouldLeadWithBlankLine, shouldQuoteIntermediateTextPart, STATUS_PREFIX, WORKTREE_PREFIX, } from '../message-formatting.js';
 import { getChannelVerbosity, getPartMessageIds, getDb, setPartMessage, getThreadSession, setThreadSession, getThreadParentSessionId, setThreadParentSessionId, getThreadWorktreeOrWorkspace, setSessionAgent, setSessionModel, clearSessionModel, getVariantCascade, setSessionStartSource, getSessionStartSource, getScheduledTask, completeScheduledTaskRunsForSession, failScheduledTaskRunsForSession, startScheduledTaskRunSession, appendSessionEventsSinceLastTimestamp, getSessionEventSnapshot, cancelSessionSleepForThread, insertThreadQueueItem, listAllThreadQueueItems, deleteThreadQueueItem, deleteThreadQueueItems, updateThreadQueueItemPayload, } from '../database.js';
 import * as orm from 'drizzle-orm';
 import * as schema from '../schema.js';
@@ -1653,14 +1653,15 @@ export class ThreadSessionRuntime {
             upToIndex: this.eventBuffer.length - 2,
         });
         const completedAt = msg.time.completed;
-        if (!wasAlreadyCompleted
-            && typeof completedAt === 'number'
-            && isAssistantMessageNaturalCompletion({ message: msg })) {
-            await this.handleNaturalAssistantCompletion({
-                completedMessageId: msg.id,
-                completedAt,
-            });
-            return;
+        if (!wasAlreadyCompleted && typeof completedAt === 'number') {
+            if (isAssistantMessageNaturalCompletion({ message: msg })) {
+                await this.handleNaturalAssistantCompletion({
+                    completedMessageId: msg.id,
+                    completedAt,
+                });
+                return;
+            }
+            await this.maybeNotifyPromptCacheClear({ sessionId, messageId: msg.id });
         }
         // Context usage notice.
         // Skip the final assistant update for a run: by the time the last
@@ -1693,7 +1694,7 @@ export class ThreadSessionRuntime {
             return;
         }
         this.lastDisplayedContextPercentage = thresholdCrossed;
-        const chunk = `${STATUS_PREFIX}context usage ${currentPercentage}%`;
+        const chunk = asSubtext(`context usage ${currentPercentage}%`);
         const sendResult = await this.thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS })
             .catch((e) => new DiscordOperationError({ operation: 'sendMessage', cause: e }));
         if (sendResult instanceof Error) {
@@ -1877,7 +1878,7 @@ export class ThreadSessionRuntime {
                         }
                         return ` (${pct.toFixed(1)}%)`;
                     })();
-                    const chunk = `${STATUS_PREFIX}${part.tool} returned ${formattedTokens} tokens${percentageSuffix}`;
+                    const chunk = asSubtext(`${STATUS_PREFIX}${part.tool} returned ${formattedTokens} tokens${percentageSuffix}`);
                     const largeOutputResult = await this.thread.send({
                         content: chunk,
                         flags: SILENT_MESSAGE_FLAGS,
@@ -2381,7 +2382,7 @@ export class ThreadSessionRuntime {
             const secs = remainingSec % 60;
             return secs > 0 ? `${mins}m ${secs}s` : `${mins}m`;
         })();
-        const chunk = `${STATUS_PREFIX}${message} - retrying in ${duration} (attempt #${attempt})`;
+        const chunk = asSubtext(`${message} - retrying in ${duration} (attempt #${attempt})`);
         const retryResult = await this.thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS })
             .catch((e) => new DiscordOperationError({ operation: 'sendMessage', cause: e }));
         if (retryResult instanceof Error) {
@@ -2447,7 +2448,7 @@ export class ThreadSessionRuntime {
         const titlePrefix = properties.title
             ? `${properties.title.trim()}: `
             : '';
-        const chunk = `${STATUS_PREFIX}${properties.variant}: ${titlePrefix}${toastMessage}`;
+        const chunk = asSubtext(`${properties.variant}: ${titlePrefix}${toastMessage}`);
         const toastResult = await this.thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS })
             .catch((e) => new DiscordOperationError({ operation: 'sendMessage', cause: e }));
         if (toastResult instanceof Error) {
@@ -3022,17 +3023,20 @@ export class ThreadSessionRuntime {
             apiAbortPromise,
         };
     }
-    abortActiveRun(reason) {
+    /** Explicit user abort: stops the run and drops all queued messages. Returns the removed items. */
+    async abortActiveRun(reason) {
         const outcome = this.abortActiveRunInternal({
             reason,
         });
         if (outcome.apiAbortPromise) {
             void outcome.apiAbortPromise;
         }
-        // Drain local queued messages after explicit abort.
-        void this.dispatchAction(() => {
-            return this.tryDrainQueue({ showIndicator: true });
+        // Enqueued synchronously, so it runs before the abort's session.idle can drain the queue.
+        let cleared = [];
+        await this.dispatchAction(async () => {
+            cleared = await this.clearQueueNow();
         });
+        return cleared;
     }
     async abortActiveRunAndWait({ reason, timeoutMs = 2_000, }) {
         const state = this.state;
@@ -3073,17 +3077,21 @@ export class ThreadSessionRuntime {
     async clearQueue() {
         let cleared = [];
         await this.dispatchAction(async () => {
-            const persistResult = await deleteThreadQueueItems(this.threadId).catch((error) => {
-                return new Error('Failed to clear persisted queue', { cause: error });
-            });
-            if (persistResult instanceof Error) {
-                logger.error(`[QUEUE] Failed to clear persisted queue for thread ${this.threadId}: ${persistResult.message}`);
-                return;
-            }
-            cleared = threadState.clearQueueItems(this.threadId);
+            cleared = await this.clearQueueNow();
         });
         return cleared;
     }
+    // Must run inside dispatchAction.
+    async clearQueueNow() {
+        const persistResult = await deleteThreadQueueItems(this.threadId).catch((error) => {
+            return new Error('Failed to clear persisted queue', { cause: error });
+        });
+        if (persistResult instanceof Error) {
+            logger.error(`[QUEUE] Failed to clear persisted queue for thread ${this.threadId}: ${persistResult.message}`);
+            return [];
+        }
+        return threadState.clearQueueItems(this.threadId);
+    }
     /** Remove a queued message by its 1-based position. */
     async removeQueuePosition(position) {
         let removed;
@@ -3912,7 +3920,7 @@ export class ThreadSessionRuntime {
         const agentLabel = agent && agent.toLowerCase() !== 'build'
             ? ` ⋅ ${agent}`
             : '';
-        const result = await sendThreadMessage(this.thread, asSystemLine(`*using ${modelLabel}${agentLabel}*`), { flags: SILENT_MESSAGE_FLAGS }).catch((e) => new DiscordOperationError({ operation: 'sendMessage', cause: e }));
+        const result = await sendThreadMessage(this.thread, asSubtext(`*using ${modelLabel}${agentLabel}*`), { flags: SILENT_MESSAGE_FLAGS }).catch((e) => new DiscordOperationError({ operation: 'sendMessage', cause: e }));
         if (result instanceof Error) {
             logger.warn(`[SESSION INFO] Failed to send model info: ${result.message}`);
         }
@@ -4041,7 +4049,7 @@ export class ThreadSessionRuntime {
             })
             : undefined;
         const mention = mentionUserId ? ` <@${mentionUserId}>` : '';
-        const footerText = asSystemLine(`*${projectInfo}${sessionDuration}${contextInfo}${modelInfo}${agentInfo}*${mention}`);
+        const footerText = asSubtext(`*${projectInfo}${sessionDuration}${contextInfo}${modelInfo}${agentInfo}*${mention}`);
         this.stopTyping();
         await sendThreadMessage(this.thread, footerText, {
             flags: shouldNotifyUser ? NOTIFY_MESSAGE_FLAGS : SILENT_MESSAGE_FLAGS,
@@ -4057,6 +4065,11 @@ export class ThreadSessionRuntime {
         this.lastSentPartKind = undefined;
     }
     async maybeNotifyPromptCacheClear({ sessionId, messageId, }) {
+        // Only the first reply after a user prompt can show a cold cache. Later steps re-read the turn's own writes.
+        const [firstAssistantId] = this.getAssistantMessageIdsForCurrentTurn({ sessionId });
+        if (firstAssistantId !== messageId) {
+            return;
+        }
         const cacheClear = getPromptCacheClear({
             events: this.eventBuffer,
             sessionId,
@@ -4070,7 +4083,7 @@ export class ThreadSessionRuntime {
             previousMessageId: cacheClear.previousMessageId,
             currentMessageId: cacheClear.currentMessageId,
         });
-        const chunk = `${STATUS_PREFIX}${formatPromptCacheClearMessage(cacheClear, systemDiff)}`;
+        const chunk = asSubtext(formatPromptCacheClearMessage(cacheClear, systemDiff));
         const sendResult = await this.thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS })
             .catch((e) => new DiscordOperationError({ operation: 'sendMessage', cause: e }));
         if (sendResult instanceof Error) {

package/dist/sleep.e2e.test.js

@@ -313,7 +313,7 @@ describe('kimaki_sleep', () => {
         -# *using deterministic-provider/deterministic-v2*
         > waiting for the deploy
 
-        ┣ kimaki_sleep until 2030-01-01T09:00:00Z _waiting for the deploy_
+        -# ┣ kimaki_sleep until 2030-01-01T09:00:00Z _waiting for the deploy_
 
         > sleep-started
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
@@ -412,7 +412,7 @@ describe('kimaki_sleep', () => {
         SLEEP_CANCEL_MARKER wait for something
         --- from: assistant (TestBot)
         -# *using deterministic-provider/deterministic-v2*
-        ┣ kimaki_sleep for 2h _cancel me_
+        -# ┣ kimaki_sleep for 2h _cancel me_
 
         > cancel-sleep-started
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*

package/dist/task-runner.js

@@ -1,7 +1,7 @@
 // Scheduled task runner for due `send --send-at` jobs and session sleep wakes.
 import { DiscordAPIError, Routes } from 'discord.js';
 import { createDiscordRest } from './discord-urls.js';
-import { ensureThreadMember } from './discord-utils.js';
+import { buildThreadStartEmbeds, ensureThreadMember } from './discord-utils.js';
 import YAML from 'yaml';
 import { claimScheduledTaskRunning, createScheduledTaskRun, failScheduledTaskRun, finishScheduledTaskRun, getDuePlannedScheduledTasks, getScheduledTask, getActiveScheduledTaskRuns, markScheduledTaskCronRescheduled, markScheduledTaskCronRetry, markScheduledTaskFailed, deleteScheduledTask, recoverStaleRunningScheduledTasks, releaseScheduledTaskClaim, setScheduledTaskRunThread, claimSessionSleepAttempt, getDueSessionSleeps, getThreadIdBySessionId, markSessionSleepFailed, } from './database.js';
 import { execAsync } from './exec-async.js';
@@ -44,7 +44,7 @@ async function executeThreadScheduledTask({ rest, task, payload, prompt, runId,
             : {}),
         ...(payload.parentSessionId ? { parentSessionId: payload.parentSessionId } : {}),
     };
-    const embed = [{ color: 0x2b2d31, footer: { text: YAML.stringify(marker) } }];
+    const embed = await buildThreadStartEmbeds(marker);
     // Newline between prefix and prompt so leading /command detection can
     // find the command on its own line.
     const prefixedPrompt = `${QUEUE_PREFIX}**kimaki-cli:**\n${prompt}`;
@@ -188,7 +188,7 @@ async function executeChannelScheduledTask({ rest, task, payload, prompt, runId,
             ...(payload.parentSessionId ? { parentSessionId: payload.parentSessionId } : {}),
         };
     const embeds = marker
-        ? [{ color: 0x2b2d31, footer: { text: YAML.stringify(marker) } }]
+        ? await buildThreadStartEmbeds(marker)
         : undefined;
     const starterResult = await rest
         .post(Routes.channelMessages(payload.channelId), {

package/dist/task-schedule.js

@@ -1,7 +1,7 @@
 // Scheduled task parsing for `send --send-at`, plus kimaki_sleep wake/result text.
 import { CronExpressionParser } from 'cron-parser';
 import * as errore from 'errore';
-import { STATUS_PREFIX } from './message-formatting.js';
+import { asSubtext } from './message-formatting.js';
 const UTC_SEND_AT_DATE_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?Z$/;
 export function getLocalTimeZone() {
     const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
@@ -88,7 +88,7 @@ export function formatSessionSleepWakeAt(wakeAt) {
 export function formatSessionSleepWakePrompt({ wakeAt, reason, }) {
     const until = formatSessionSleepWakeAt(wakeAt);
     const reasonLine = reason?.trim() ? `\nReason: ${reason.trim()}` : '';
-    return `${STATUS_PREFIX}Woke after sleeping until ${until}${reasonLine}\nContinue the work you were waiting for.`;
+    return `${asSubtext(`Woke after sleeping until ${until}`)}${reasonLine}\nContinue the work you were waiting for.`;
 }
 // Tool result after persist. Keep "Sleeping until" first so e2e matchers still hit.
 // Do not say "woken" or "Woke after": models treat that as the wake turn.

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

@@ -583,7 +583,7 @@ e2eTest('thread message queue ordering', () => {
         > running create file
         > creating marker
 
-        ┣ bash _Create marker file for e2e test_
+        -# ┣ bash _Create marker file for e2e test_
 
         > file created
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"

package/dist/undo-redo.e2e.test.js

@@ -156,7 +156,7 @@ e2eTest('/undo sets revert state and cleans up on next prompt', () => {
         -# *using deterministic-provider/deterministic-v2*
         > creating undo file
 
-        ┣ bash _Create undo marker file_
+        -# ┣ bash _Create undo marker file_
 
         > undo file created
         -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.30.0",
+  "version": "0.30.1",
   "repository": "https://github.com/remorses/kimaki",
   "bin": "bin.js",
   "exports": {
@@ -33,8 +33,8 @@
     "undici": "^8.0.2",
     "discord-digital-twin": "^0.1.2",
     "opencode-cached-provider": "^0.0.1",
-    "db": "^0.0.0",
-    "opencode-deterministic-provider": "^0.0.1"
+    "opencode-deterministic-provider": "^0.0.1",
+    "db": "^0.0.0"
   },
   "dependencies": {
     "@ai-sdk/google": "^3.0.53",
@@ -71,11 +71,11 @@
     "zod": "^4.3.6",
     "zustand": "^5.0.11",
     "@subrouter/cli": "^0.6.1",
-    "@subrouter/opencode": "^0.5.1",
     "errore": "^0.14.1",
-    "libsqlproxy": "^0.1.0",
     "opencode-injection-guard": "^0.2.1",
-    "traforo": "^0.7.2"
+    "libsqlproxy": "^0.1.0",
+    "traforo": "^0.7.2",
+    "@subrouter/opencode": "^0.5.1"
   },
   "optionalDependencies": {
     "@snazzah/davey": "^0.1.10",

package/skills/holocron/SKILL.md

@@ -746,34 +746,6 @@ npx -y "@holocron.so/cli" whoami
 If `whoami` succeeds and shows user, orgs, and projects, skip login. Only run
 `npx -y "@holocron.so/cli" login` if `whoami` fails.
 
-## www hostname
-
-For every new site on a custom domain, **301 `www` to the apex in one hop**.
-Never leave `www` on another host (Vercel, Pages, a second worker). Never use
-307. Chain `http://www` → `https://www` → apex is two hops; collapse it.
-
-On Cloudflare Workers:
-
-1. Add `www.example.com` as a `custom_domain` on the **same** worker as the apex.
-2. Redirect `www` to `https://example.com` + path + query with status **301**.
-
-```ts
-.use(({ request }, next) => {
-  const url = new URL(request.url)
-  if (!url.hostname.startsWith('www.')) return next()
-  url.hostname = url.hostname.slice('www.'.length)
-  url.protocol = 'https:'
-  throw redirect(url.toString(), { status: 301 })
-})
-```
-
-```jsonc
-"routes": [
-  { "pattern": "example.com", "custom_domain": true },
-  { "pattern": "www.example.com", "custom_domain": true }
-]
-```
-
 ## Deploy
 
 When the user asks to "deploy the site", they may mean deploying with their own

package/src/cli-commands/send.ts

@@ -6,7 +6,6 @@
 import { goke } from 'goke'
 import { z } from 'zod'
 import { note } from '@clack/prompts'
-import YAML from 'yaml'
 import * as errore from 'errore'
 import type { OpencodeClient, Event as OpenCodeEvent } from '@opencode-ai/sdk/v2'
 import { Events, ActivityType, type PresenceStatusData, type Guild, Routes } from 'discord.js'
@@ -30,7 +29,7 @@ import { QUEUE_PREFIX } from '../message-formatting.js'
 import type { ThreadStartMarker } from '../system-message.js'
 import { buildOpencodeEventLogLine } from '../session-handler/opencode-session-event-log.js'
 import { createDiscordRest } from '../discord-urls.js'
-import { archiveThread, ensureThreadMember, uploadFilesToDiscord, stripMentions } from '../discord-utils.js'
+import { archiveThread, buildThreadStartEmbeds, ensureThreadMember, uploadFilesToDiscord, stripMentions } from '../discord-utils.js'
 import { setDataDir, setProjectsDir, getDataDir, getProjectsDir } from '../config.js'
 import { execAsync, resolveSessionWorkingDirectory, isGitRepositoryRoot } from '../worktrees.js'
 import { upgrade, getCurrentVersion } from '../upgrade.js'
@@ -565,12 +564,7 @@ cli
             ...(options.injectionGuard?.length ? { injectionGuardPatterns: options.injectionGuard } : {}),
             ...(options.parentSession && { parentSessionId: options.parentSession }),
           }
-          const promptEmbed = [
-            {
-              color: 0x2b2d31,
-              footer: { text: YAML.stringify(threadPromptMarker) },
-            },
-          ]
+          const promptEmbed = await buildThreadStartEmbeds(threadPromptMarker)
 
           // Prefix the prompt so it's clear who sent it (matches /queue format).
           // Use a newline between prefix and prompt so leading /command
@@ -779,7 +773,7 @@ cli
               ...(options.parentSession && { parentSessionId: options.parentSession }),
             }
         const autoStartEmbed = embedMarker
-          ? [{ color: 0x2b2d31, footer: { text: YAML.stringify(embedMarker) } }]
+          ? await buildThreadStartEmbeds(embedMarker)
           : undefined
 
         const starterMessage = await sendDiscordMessageWithOptionalAttachment({

package/src/commands/abort.ts

@@ -7,7 +7,11 @@ import {
   type ThreadChannel,
 } from 'discord.js'
 import type { CommandContext } from './types.js'
-import { cancelSessionSleepForThread, getThreadSession } from '../database.js'
+import {
+  cancelSessionSleepForThread,
+  deleteThreadQueueItems,
+  getThreadSession,
+} from '../database.js'
 import { getOpencodeClient, initializeOpencodeForDirectory } from '../opencode.js'
 import {
   resolveWorkingDirectory,
@@ -71,11 +75,20 @@ export async function handleAbortCommand({
   // wake would still fire later and restart a session the user just stopped.
   await cancelSessionSleepForThread({ threadId: channel.id })
 
-  // abortActiveRun delegates to session.abort(), run settlement stays event-driven.
+  // abortActiveRun delegates to session.abort() and clears the /queue, so
+  // queued messages are not sent after abort or restored after a restart.
   const runtime = getRuntime(channel.id)
+  let clearedCount = 0
   if (runtime) {
-    runtime.abortActiveRun('user-requested')
+    const cleared = await runtime.abortActiveRun('user-requested')
+    clearedCount = cleared.length
   } else {
+    const deleteResult = await deleteThreadQueueItems(channel.id).catch((error) => {
+      return new Error('Failed to clear persisted queue', { cause: error })
+    })
+    if (deleteResult instanceof Error) {
+      logger.error(`[ABORT] ${deleteResult.message}:`, deleteResult.cause)
+    }
     // No runtime but session exists — fall back to direct API abort
     const serverResult = await initializeOpencodeForDirectory(projectDirectory)
     if (serverResult instanceof Error) {
@@ -92,6 +105,9 @@ export async function handleAbortCommand({
     }
   }
 
-  await command.editReply('Request **aborted**')
+  const queueNote = clearedCount > 0
+    ? `, cleared ${clearedCount} queued message${clearedCount > 1 ? 's' : ''}`
+    : ''
+  await command.editReply(`Request **aborted**${queueNote}`)
   logger.log(`Session ${sessionId} aborted by user`)
 }