kimaki 0.4.90 → 0.4.91

package/dist/discord-bot.js

@@ -1,13 +1,14 @@
 // Core Discord bot module that handles message events and bot lifecycle.
 // Bridges Discord messages to OpenCode sessions, manages voice connections,
 // and orchestrates the main event loop for the Kimaki bot.
-import { initDatabase, closeDatabase, getThreadWorktree, getThreadSession, getChannelWorktreesEnabled, getChannelMentionMode, getChannelDirectory, getPrisma, cancelAllPendingIpcRequests, deleteChannelDirectoryById, } from './database.js';
+import { initDatabase, closeDatabase, getThreadWorktree, getThreadSession, getChannelWorktreesEnabled, getChannelMentionMode, getChannelDirectory, getPrisma, cancelAllPendingIpcRequests, deleteChannelDirectoryById, createPendingWorktree, setWorktreeReady, } from './database.js';
 import { stopOpencodeServer, } from './opencode.js';
 import { formatWorktreeName, createWorktreeInBackground, worktreeCreatingMessage } from './commands/new-worktree.js';
+import { validateWorktreeDirectory, git } from './worktrees.js';
 import { WORKTREE_PREFIX } from './commands/merge-worktree.js';
 import { escapeBackticksInCodeBlocks, splitMarkdownForDiscord, sendThreadMessage, SILENT_MESSAGE_FLAGS, NOTIFY_MESSAGE_FLAGS, reactToThread, stripMentions, hasKimakiBotPermission, hasNoKimakiRole, } from './discord-utils.js';
 import { getOpencodeSystemMessage, isInjectedPromptMarker, } from './system-message.js';
-import yaml from 'js-yaml';
+import YAML from 'yaml';
 import { getTextAttachments, resolveMentions, } from './message-formatting.js';
 import { isVoiceAttachment } from './voice-attachment.js';
 import { preprocessExistingThreadMessage, preprocessNewThreadMessage, } from './message-preprocessing.js';
@@ -19,7 +20,7 @@ import { cancelHtmlActionsForThread } from './html-actions.js';
 import { ensureKimakiCategory, ensureKimakiAudioCategory, createProjectChannels, getChannelsWithDescriptions, } from './channel-management.js';
 import { voiceConnections, cleanupVoiceConnection, registerVoiceStateHandler, } from './voice-handler.js';
 import {} from './session-handler/model-utils.js';
-import { getOrCreateRuntime, disposeRuntime, } from './session-handler/thread-session-runtime.js';
+import { getRuntime, getOrCreateRuntime, disposeRuntime, } from './session-handler/thread-session-runtime.js';
 import { runShellCommand } from './commands/run-command.js';
 import { registerInteractionHandler } from './interaction-handler.js';
 import { getDiscordRestApiUrl } from './discord-urls.js';
@@ -35,15 +36,16 @@ export { getOpencodeSystemMessage } from './system-message.js';
 export { ensureKimakiCategory, ensureKimakiAudioCategory, createProjectChannels, createDefaultKimakiChannel, getChannelsWithDescriptions, } from './channel-management.js';
 import { ChannelType, Client, Events, GatewayIntentBits, Partials, ThreadAutoArchiveDuration, } from 'discord.js';
 import fs from 'node:fs';
+import path from 'node:path';
 import * as errore from 'errore';
 import { createLogger, formatErrorWithStack, LogPrefix } from './logger.js';
 import { writeHeapSnapshot, startHeapMonitor } from './heap-monitor.js';
 import { startTaskRunner } from './task-runner.js';
-import { setGlobalDispatcher, Agent } from 'undici';
 // Increase connection pool to prevent deadlock when multiple sessions have open SSE streams.
 // Each session's event.subscribe() holds a connection; without enough connections,
 // regular HTTP requests (question.reply, session.prompt) get blocked → deadlock.
-setGlobalDispatcher(new Agent({ headersTimeout: 0, bodyTimeout: 0, connections: 500 }));
+// undici is a transitive dep from discord.js — not listed in our package.json.
+// Types are declared in src/undici.d.ts.
 const discordLogger = createLogger(LogPrefix.DISCORD);
 const voiceLogger = createLogger(LogPrefix.VOICE);
 // Well-known WebSocket and Discord Gateway close codes for diagnostic logging.
@@ -90,7 +92,7 @@ function parseEmbedFooterMarker({ footer, }) {
         return undefined;
     }
     try {
-        const parsed = yaml.load(footer);
+        const parsed = YAML.parse(footer);
         if (!parsed || typeof parsed !== 'object') {
             return undefined;
         }
@@ -369,10 +371,14 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                         projectDirectory = channelConfig.directory;
                     }
                 }
-                // Check if this thread is a worktree thread
+                // Check if this thread is a worktree thread.
+                // When the runtime exists in memory, pending worktrees are handled by
+                // the preprocess chain (messages queue behind the worktree promise).
+                // After a bot restart the runtime is gone, so we must reject messages
+                // for pending worktrees to avoid running in the base directory.
                 const worktreeInfo = await getThreadWorktree(thread.id);
                 if (worktreeInfo) {
-                    if (worktreeInfo.status === 'pending') {
+                    if (worktreeInfo.status === 'pending' && !getRuntime(thread.id)) {
                         await message.reply({
                             content: '⏳ Worktree is still being created. Please wait...',
                             flags: SILENT_MESSAGE_FLAGS,
@@ -401,9 +407,12 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     });
                     return;
                 }
-                // ! prefix runs a shell command instead of starting/continuing a session
-                // Use worktree directory if available, so commands run in the worktree cwd
-                if (message.content?.startsWith('!') && projectDirectory) {
+                // ! prefix runs a shell command instead of starting/continuing a session.
+                // Use worktree directory if available, so commands run in the worktree cwd.
+                // Skip shell commands while worktree is pending — they'd run in the base dir.
+                if (message.content?.startsWith('!') &&
+                    projectDirectory &&
+                    worktreeInfo?.status !== 'pending') {
                     const shellCmd = message.content.slice(1).trim();
                     if (shellCmd) {
                         const shellDir = worktreeInfo?.status === 'ready' &&
@@ -451,28 +460,12 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                             reason: 'user sent a new message while permission was pending',
                         });
                     }
-                    // For text messages: pass the content as the question answer so the
-                    // model sees the user's response. The early return prevents the message
-                    // from also being sent as a new prompt (duplicate).
-                    // For voice/image messages: message.content is "" (audio is in
-                    // attachments, transcription happens later). Passing "" as the answer
-                    // loses the content entirely. Instead, reply with "" to properly
-                    // unblock OpenCode's question.waitForReply (without a reply the next
-                    // promptAsync immediately fails with MessageAbortedError), then let
-                    // the voice message flow through normal preprocessing — it gets
-                    // transcribed and queued as the next user message after the model
-                    // finishes responding to the empty answer.
-                    if (message.content.trim().length > 0) {
-                        const questionResult = await cancelPendingQuestion(thread.id, message.content);
-                        if (questionResult === 'replied') {
-                            void cancelPendingFileUpload(thread.id);
-                            return;
-                        }
-                    }
-                    else if (hasPendingQuestionForThread(thread.id)) {
-                        // Reply empty to unblock the question tool — no early return so
-                        // the voice/image message continues through to enqueueIncoming.
-                        await cancelPendingQuestion(thread.id, '');
+                    const dismissedQuestion = hasPendingQuestionForThread(thread.id);
+                    if (dismissedQuestion) {
+                        await cancelPendingQuestion(thread.id);
+                        await runtime.abortActiveRunAndWait({
+                            reason: 'user sent a new message while question was pending',
+                        });
                     }
                     void cancelPendingFileUpload(thread.id);
                 }
@@ -593,8 +586,11 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                 // Add user to thread so it appears in their sidebar
                 await thread.members.add(message.author.id);
                 discordLogger.log(`Created thread "${thread.name}" (${thread.id})`);
-                // Create worktree if worktrees are enabled (CLI flag OR channel setting)
-                let sessionDirectory = projectDirectory;
+                // Create runtime immediately so follow-up messages queue naturally
+                // via the preprocess chain instead of being rejected with "please wait".
+                // When worktrees are enabled, the worktree promise runs concurrently
+                // and the first message's preprocess callback awaits it before resolving.
+                let worktreePromise;
                 if (shouldUseWorktrees) {
                     const worktreeName = formatWorktreeName(hasVoice ? `voice-${Date.now()}` : threadName.slice(0, 50));
                     discordLogger.log(`[WORKTREE] Creating worktree: ${worktreeName}`);
@@ -604,22 +600,19 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                         flags: SILENT_MESSAGE_FLAGS,
                     })
                         .catch(() => undefined);
-                    const result = await createWorktreeInBackground({
+                    worktreePromise = createWorktreeInBackground({
                         thread,
                         starterMessage: worktreeStatusMessage,
                         worktreeName,
                         projectDirectory,
                         rest: discordClient.rest,
                     });
-                    if (!(result instanceof Error)) {
-                        sessionDirectory = result;
-                    }
                 }
                 const channelRuntime = getOrCreateRuntime({
                     threadId: thread.id,
                     thread,
-                    projectDirectory: sessionDirectory,
-                    sdkDirectory: sessionDirectory,
+                    projectDirectory,
+                    sdkDirectory: projectDirectory,
                     channelId: textChannel.id,
                     appId: currentAppId,
                 });
@@ -630,7 +623,20 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     sourceMessageId: message.id,
                     sourceThreadId: thread.id,
                     appId: currentAppId,
-                    preprocess: () => {
+                    preprocess: async () => {
+                        // Wait for worktree creation + install before preprocessing.
+                        // Follow-up messages queue behind this in the preprocess chain.
+                        let sessionDirectory = projectDirectory;
+                        if (worktreePromise) {
+                            const result = await worktreePromise;
+                            if (!(result instanceof Error)) {
+                                sessionDirectory = result;
+                                channelRuntime.handleDirectoryChanged({
+                                    oldDirectory: projectDirectory,
+                                    newDirectory: sessionDirectory,
+                                });
+                            }
+                        }
                         return preprocessNewThreadMessage({
                             message,
                             thread,
@@ -688,6 +694,10 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
             if (!embedFooter) {
                 return;
             }
+            // Only process markers from our own bot messages to prevent crafted embeds
+            if (starterMessage.author?.id !== discordClient.user?.id) {
+                return;
+            }
             const marker = parseEmbedFooterMarker({
                 footer: embedFooter,
             });
@@ -722,11 +732,11 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                 });
                 return;
             }
-            // Create worktree if requested
-            const sessionDirectory = await (async () => {
-                if (!marker.worktree) {
-                    return projectDirectory;
-                }
+            // Start worktree creation concurrently if requested.
+            // The runtime is created immediately so follow-up messages queue
+            // naturally; the worktree promise is awaited inside enqueueIncoming.
+            let worktreePromise;
+            if (marker.worktree) {
                 discordLogger.log(`[BOT_SESSION] Creating worktree: ${marker.worktree}`);
                 const worktreeStatusMessage = await thread
                     .send({
@@ -734,30 +744,72 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                     flags: SILENT_MESSAGE_FLAGS,
                 })
                     .catch(() => undefined);
-                const result = await createWorktreeInBackground({
+                worktreePromise = createWorktreeInBackground({
                     thread,
                     starterMessage: worktreeStatusMessage,
                     worktreeName: marker.worktree,
                     projectDirectory,
                     rest: discordClient.rest,
                 });
-                if (result instanceof Error) {
-                    return projectDirectory;
+            }
+            // --cwd: reuse an existing worktree directory. Revalidate at bot-time
+            // (CLI validated at send-time but the path could become stale).
+            // Store in thread_worktrees as ready with origin=external so
+            // destructive actions (merge, delete) are gated.
+            // --cwd: if it matches projectDirectory, ignore silently (already the default).
+            // Otherwise revalidate as a git worktree and store with origin=external.
+            let cwdDirectory;
+            if (marker.cwd) {
+                const cwdResult = await validateWorktreeDirectory({
+                    projectDirectory,
+                    candidatePath: marker.cwd,
+                });
+                if (cwdResult instanceof Error) {
+                    discordLogger.error(`[BOT_SESSION] --cwd validation failed: ${cwdResult.message}`);
+                    await thread.send({
+                        content: `✗ --cwd validation failed: ${cwdResult.message.slice(0, 1900)}`,
+                        flags: NOTIFY_MESSAGE_FLAGS,
+                    });
+                    return;
+                }
+                // If cwd is the same as projectDirectory, skip worktree setup entirely
+                if (path.resolve(cwdResult) !== path.resolve(projectDirectory)) {
+                    cwdDirectory = cwdResult;
+                    // Resolve actual branch name instead of using directory basename
+                    const branchResult = await git(cwdDirectory, 'symbolic-ref --short HEAD');
+                    const cwdWorktreeName = branchResult instanceof Error
+                        ? path.basename(cwdDirectory)
+                        : branchResult;
+                    await createPendingWorktree({
+                        threadId: thread.id,
+                        worktreeName: cwdWorktreeName,
+                        projectDirectory,
+                    });
+                    await setWorktreeReady({
+                        threadId: thread.id,
+                        worktreeDirectory: cwdDirectory,
+                    });
+                    // React with tree emoji to mark as worktree thread
+                    await reactToThread({
+                        rest: discordClient.rest,
+                        threadId: thread.id,
+                        channelId: parent.id,
+                        emoji: '🌳',
+                    });
                 }
-                return result;
-            })();
+            }
             discordLogger.log(`[BOT_SESSION] Starting session for thread ${thread.id} with prompt: "${prompt.slice(0, 50)}..."`);
             const botThreadStartSource = parseSessionStartSourceFromMarker(marker);
             const runtime = getOrCreateRuntime({
                 threadId: thread.id,
                 thread,
                 projectDirectory,
-                sdkDirectory: sessionDirectory,
+                sdkDirectory: projectDirectory,
                 channelId: parent.id,
                 appId: currentAppId,
             });
             await runtime.enqueueIncoming({
-                prompt,
+                prompt: '',
                 userId: marker.userId || '',
                 username: marker.username || 'bot',
                 appId: currentAppId,
@@ -772,6 +824,26 @@ export async function startDiscordBot({ token, appId, discordClient, useWorktree
                         scheduledTaskId: botThreadStartSource.scheduledTaskId,
                     }
                     : undefined,
+                preprocess: async () => {
+                    // Wait for worktree creation + install before starting session.
+                    if (worktreePromise) {
+                        const result = await worktreePromise;
+                        if (!(result instanceof Error)) {
+                            runtime.handleDirectoryChanged({
+                                oldDirectory: projectDirectory,
+                                newDirectory: result,
+                            });
+                        }
+                    }
+                    // --cwd: switch sdkDirectory to the existing worktree path
+                    if (cwdDirectory) {
+                        runtime.handleDirectoryChanged({
+                            oldDirectory: projectDirectory,
+                            newDirectory: cwdDirectory,
+                        });
+                    }
+                    return { prompt, mode: 'opencode' };
+                },
             });
         }
         catch (error) {

package/dist/discord-utils.test.js

@@ -69,6 +69,25 @@ describe('splitMarkdownForDiscord', () => {
       ]
     `);
     });
+    test('task list code block does not duplicate checkbox marker when splitting', () => {
+        const content = `- [ ] Do thing
+  \`\`\`sh
+  echo hi
+  \`\`\`
+`;
+        const result = splitMarkdownForDiscord({ content, maxLength: 80 });
+        expect(result.join('')).toContain('- [ ] Do thing\n');
+        expect(result.join('')).not.toContain('- [ ] [ ] Do thing');
+        expect(result).toMatchInlineSnapshot(`
+      [
+        "- [ ] Do thing
+        \`\`\`sh
+        echo hi
+        \`\`\`
+      ",
+      ]
+    `);
+    });
 });
 describe('hasKimakiBotPermission', () => {
     test('allows API interaction member when kimaki role exists', () => {

package/dist/errors.js

@@ -125,11 +125,6 @@ export class NothingToMergeError extends createTaggedError({
     message: 'No commits to merge -- branch is already up to date with $target',
 }) {
 }
-export class SquashError extends createTaggedError({
-    name: 'SquashError',
-    message: 'Squash failed: $reason',
-}) {
-}
 export class RebaseConflictError extends createTaggedError({
     name: 'RebaseConflictError',
     message: 'Rebase conflict while rebasing onto $target. Resolve conflicts, then run merge again.',

package/dist/exec-async.js

@@ -0,0 +1,26 @@
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+const DEFAULT_EXEC_TIMEOUT_MS = 10_000;
+const _execAsync = promisify(exec);
+export function execAsync(command, options) {
+    const timeoutMs = options?.timeout || DEFAULT_EXEC_TIMEOUT_MS;
+    const execPromise = _execAsync(command, options);
+    let timer;
+    const timeoutPromise = new Promise((_, reject) => {
+        timer = setTimeout(() => {
+            const pid = execPromise.child?.pid;
+            if (pid) {
+                try {
+                    process.kill(-pid, 'SIGTERM');
+                }
+                catch {
+                    execPromise.child?.kill('SIGTERM');
+                }
+            }
+            reject(new Error(`Command timed out after ${timeoutMs}ms: ${command}`));
+        }, timeoutMs);
+    });
+    return Promise.race([execPromise, timeoutPromise]).finally(() => {
+        clearTimeout(timer);
+    });
+}

package/dist/external-opencode-sync.js

@@ -367,8 +367,7 @@ async function pulseTypingForBusySessions({ discordClient, statuses, }) {
         }
     }
 }
-// Use experimental.session.list (global, all directories) to reduce from
-// N*2 HTTP calls to 1 global list + per-active-directory status calls.
+const EXTERNAL_SYNC_MAX_SESSIONS = 50;
 async function pollExternalSessions({ discordClient, }) {
     const trackedChannels = await listTrackedTextChannels();
     const directoryTargets = groupTrackedChannelsByDirectory(trackedChannels)
@@ -378,89 +377,52 @@ async function pollExternalSessions({ discordClient, }) {
     if (directoryTargets.length === 0) {
         return;
     }
-    // Build a lookup: directory → { channelId, startMs }
-    const directoryMap = new Map();
     for (const target of directoryTargets) {
-        directoryMap.set(target.directory, {
-            channelId: target.channelId,
-            startMs: target.startMs,
+        const directory = target.directory;
+        const channelId = target.channelId;
+        const startMs = target.startMs;
+        const clientResult = await initializeOpencodeForDirectory(directory, {
+            channelId,
         });
-    }
-    // Use earliest startMs across all directories for the global query
-    const globalStartMs = Math.min(...directoryTargets.map((t) => {
-        return t.startMs;
-    }));
-    // Get one opencode client — try each existing directory until one succeeds
-    let client;
-    for (const target of directoryTargets) {
-        const result = await initializeOpencodeForDirectory(target.directory, {
-            channelId: target.channelId,
-        });
-        if (!(result instanceof Error)) {
-            client = result();
-            break;
-        }
-    }
-    if (!client) {
-        return;
-    }
-    // One global API call for all sessions across all directories.
-    // Results are sorted by most recently updated, so a fixed limit of 50
-    // is enough — we always get the most active sessions first.
-    const sessionsResponse = await client.experimental.session.list({
-        roots: true,
-        start: globalStartMs,
-        limit: 50,
-    }).catch((error) => {
-        return new Error('Failed to list global sessions', { cause: error });
-    });
-    if (sessionsResponse instanceof Error) {
-        logger.warn(`[EXTERNAL_SYNC] ${sessionsResponse.message}`);
-        return;
-    }
-    const allSessions = sessionsResponse.data || [];
-    // Group sessions by directory, filtering to tracked directories only
-    const sessionsByDirectory = new Map();
-    for (const session of allSessions) {
-        const target = directoryMap.get(session.directory);
-        if (!target) {
-            continue;
-        }
-        // Filter by per-directory startMs (time.updated or time.created)
-        if ((session.time.updated || session.time.created || 0) < target.startMs) {
+        if (clientResult instanceof Error) {
+            logger.warn(`[EXTERNAL_SYNC] Failed to initialize OpenCode for ${directory}: ${clientResult.message}`);
             continue;
         }
-        // Skip sessions whose title hasn't been generated yet
-        if (/^new session\s*-/i.test(session.title || '')) {
+        const client = clientResult();
+        const sessionsResponse = await client.session.list({
+            directory,
+            start: startMs,
+            limit: EXTERNAL_SYNC_MAX_SESSIONS,
+        }).catch((error) => {
+            return new Error(`Failed to list sessions for ${directory}`, {
+                cause: error,
+            });
+        });
+        if (sessionsResponse instanceof Error) {
+            logger.warn(`[EXTERNAL_SYNC] ${sessionsResponse.message}`);
             continue;
         }
-        const existing = sessionsByDirectory.get(session.directory) || [];
-        existing.push(session);
-        sessionsByDirectory.set(session.directory, existing);
-    }
-    // Fetch session.status() only for directories that have sessions to sync.
-    // session.status() is instance-scoped (uses x-opencode-directory header),
-    // so we must call it per directory — but only for active ones, not all 30+.
-    const activeDirectories = [...sessionsByDirectory.keys()];
-    const statusResults = await Promise.all(activeDirectories.map(async (directory) => {
-        const res = await client.session.status({ directory }).catch(() => {
+        const statusesResponse = await client.session.status({
+            directory,
+        }).catch(() => {
             return null;
         });
-        return res?.data ? Object.entries(res.data) : [];
-    }));
-    const mergedStatuses = Object.fromEntries(statusResults.flat());
-    // Pulse typing for busy sessions
-    await pulseTypingForBusySessions({ discordClient, statuses: mergedStatuses }).catch(() => { });
-    for (const [directory, sessions] of sessionsByDirectory) {
-        const target = directoryMap.get(directory);
+        if (statusesResponse?.data) {
+            await pulseTypingForBusySessions({
+                discordClient,
+                statuses: statusesResponse.data,
+            }).catch(() => { });
+        }
+        const sessions = (sessionsResponse.data || []).filter((session) => {
+            return !/^new session\s*-/i.test(session.title || '');
+        });
         const sorted = sortSessionsByRecency(sessions);
-        logger.log(`[EXTERNAL_SYNC] ${directory}: ${sorted.length} sessions to sync`);
         for (const session of sorted) {
             await syncSessionToThread({
                 client,
                 discordClient,
                 directory,
-                channelId: target.channelId,
+                channelId,
                 sessionId: session.id,
                 sessionTitle: session.title,
             }).catch((error) => {
@@ -478,7 +440,6 @@ export function startExternalOpencodeSessionSync({ discordClient, }) {
     if (externalSyncInterval) {
         return;
     }
-    logger.log(`[EXTERNAL_SYNC] started, polling every ${EXTERNAL_SYNC_INTERVAL_MS}ms`);
     let polling = false;
     const runPoll = async () => {
         if (polling) {

package/dist/forum-sync/config.js

@@ -3,7 +3,7 @@
 // On first run, migrates any existing forum-sync.json into the DB.
 import fs from 'node:fs';
 import path from 'node:path';
-import yaml from 'js-yaml';
+import YAML from 'yaml';
 import { getDataDir } from '../config.js';
 import { getForumSyncConfigs, upsertForumSyncConfig } from '../database.js';
 import { createLogger } from '../logger.js';
@@ -29,7 +29,7 @@ async function migrateLegacyConfig({ appId }) {
     const raw = fs.readFileSync(configPath, 'utf8');
     let parsed;
     try {
-        parsed = yaml.load(raw);
+        parsed = YAML.parse(raw);
     }
     catch {
         forumLogger.warn(`Failed to parse legacy ${LEGACY_CONFIG_FILE}, skipping migration`);

package/dist/forum-sync/markdown.js

@@ -1,7 +1,7 @@
 // Markdown parsing, serialization, and section formatting for forum sync.
 // Handles frontmatter extraction, message section building, and
 // conversion between Discord messages and markdown format.
-import yaml from 'js-yaml';
+import YAML from 'yaml';
 import * as errore from 'errore';
 import { ForumFrontmatterParseError, } from './types.js';
 export function toStringArray({ value }) {
@@ -25,7 +25,7 @@ export function parseFrontmatter({ markdown, }) {
     const rawFrontmatter = markdown.slice(4, end);
     const body = markdown.slice(end + 5).trim();
     const parsed = errore.try({
-        try: () => yaml.load(rawFrontmatter),
+        try: () => YAML.parse(rawFrontmatter),
         catch: (cause) => new ForumFrontmatterParseError({ reason: 'yaml parse failed', cause }),
     });
     if (parsed instanceof Error || !parsed || typeof parsed !== 'object') {
@@ -34,13 +34,9 @@ export function parseFrontmatter({ markdown, }) {
     return { frontmatter: parsed, body };
 }
 export function stringifyFrontmatter({ frontmatter, body, }) {
-    const yamlText = yaml
-        .dump(frontmatter, {
+    const yamlText = YAML.stringify(frontmatter, null, {
         lineWidth: 120,
-        noRefs: true,
-        sortKeys: false,
-    })
-        .trim();
+    }).trim();
     return `---\n${yamlText}\n---\n\n${body.trim()}\n`;
 }
 export function splitSections({ body }) {

package/dist/hrana-server.js

@@ -227,7 +227,9 @@ export async function evictExistingInstance({ port }) {
         try: () => {
             process.kill(targetPid, 'SIGTERM');
         },
-        catch: (e) => e,
+        catch: (e) => new Error('Failed to send SIGTERM to existing kimaki process', {
+            cause: e,
+        }),
     });
     if (killResult instanceof Error) {
         hranaLogger.log(`Failed to kill PID ${targetPid}: ${killResult.message}`);
@@ -243,12 +245,18 @@ export async function evictExistingInstance({ port }) {
     if (secondProbe instanceof Error)
         return;
     hranaLogger.log(`PID ${targetPid} still alive after SIGTERM, sending SIGKILL`);
-    errore.try({
+    const forceKillResult = errore.try({
         try: () => {
             process.kill(targetPid, 'SIGKILL');
         },
-        catch: (e) => e,
+        catch: (e) => new Error('Failed to send SIGKILL to existing kimaki process', {
+            cause: e,
+        }),
     });
+    if (forceKillResult instanceof Error) {
+        hranaLogger.log(`Failed to force-kill PID ${targetPid}: ${forceKillResult.message}`);
+        return;
+    }
     await new Promise((resolve) => {
         setTimeout(resolve, 1000);
     });