kimaki 0.29.0 → 0.30.0

package/dist/gateway-proxy.e2e.test.js

@@ -323,9 +323,9 @@ describeIf('gateway-proxy e2e', () => {
         "--- from: user (proxy-tester)
         hello from gateway proxy test
         --- from: assistant (TestBot)
-        > *using deterministic-provider/deterministic-v2*
+        -# *using deterministic-provider/deterministic-v2*
         > gateway-proxy-reply
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@900000000000000001>"
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
       `);
         expect(reply).toBeDefined();
         expect(getMessageVisibleText(reply).trim().length).toBeGreaterThan(0);
@@ -350,14 +350,14 @@ describeIf('gateway-proxy e2e', () => {
         "--- from: user (proxy-tester)
         hello from gateway proxy test
         --- from: assistant (TestBot)
-        > *using deterministic-provider/deterministic-v2*
+        -# *using deterministic-provider/deterministic-v2*
         > gateway-proxy-reply
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@900000000000000001>
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         --- from: user (proxy-tester)
         follow up through proxy
         --- from: assistant (TestBot)
         > gateway-proxy-reply
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@900000000000000001>"
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
       `);
         expect(reply).toBeDefined();
         expect(getMessageVisibleText(reply).trim().length).toBeGreaterThan(0);
@@ -382,14 +382,14 @@ describeIf('gateway-proxy e2e', () => {
         "--- from: user (proxy-tester)
         hello from gateway proxy test
         --- from: assistant (TestBot)
-        > *using deterministic-provider/deterministic-v2*
+        -# *using deterministic-provider/deterministic-v2*
         > gateway-proxy-reply
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@900000000000000001>
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         --- from: user (proxy-tester)
         follow up through proxy
         --- from: assistant (TestBot)
         > gateway-proxy-reply
-        > *project ⋅ main ⋅ <1s ⋅ 0% ⋅ deterministic-v2* <@900000000000000001>
+        -# *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
         --- from: user (proxy-tester)
         !echo proxy-shell-test
         --- from: assistant (TestBot)
@@ -417,7 +417,7 @@ describeIf('gateway-proxy e2e', () => {
         "--- from: user (proxy-tester)
         second message through proxy
         --- from: assistant (TestBot)
-        > *using deterministic-provider/deterministic-v2*"
+        -# *using deterministic-provider/deterministic-v2*"
       `);
         expect(reply).toBeDefined();
         expect(getMessageVisibleText(reply).trim().length).toBeGreaterThan(0);

package/dist/hrana-server.js

@@ -148,7 +148,7 @@ export async function startHranaServer({ dbPath, bindAll = false, }) {
         // Health check — no auth required
         if (pathname === '/health') {
             res.writeHead(200, { 'content-type': 'application/json' });
-            res.end(JSON.stringify({ status: 'ok', pid: process.pid }));
+            res.end(JSON.stringify({ status: 'ok', pid: process.pid, wrapperPid: getWrapperPid() }));
             return;
         }
         // OpenCode server port discovery — no auth required (localhost only).
@@ -230,8 +230,12 @@ export async function stopHranaServer() {
  * Evict a previous kimaki instance on the lock port.
  * Fetches /health to get the running process PID, then kills it directly.
  * No lsof/netstat/spawnSync needed — the PID comes from the health response.
+ *
+ * SIGTERM first so the old bot can clean up. Its own shutdown deadline is
+ * 15s, so after a longer grace period we SIGKILL: a stuck process must never
+ * block every future start. Safe because the PID comes from our own /health.
  */
-export async function evictExistingInstance({ port }) {
+export async function evictExistingInstance({ port, gracePeriodMs = 20_000, }) {
     const url = `http://127.0.0.1:${port}/health`;
     const probe = await fetch(url, { signal: AbortSignal.timeout(1000) }).catch((e) => new FetchError({ url, cause: e }));
     if (probe instanceof Error)
@@ -242,9 +246,15 @@ export async function evictExistingInstance({ port }) {
     const targetPid = body.pid;
     if (!targetPid || targetPid === process.pid)
         return;
-    hranaLogger.log(`Evicting existing kimaki process (PID: ${targetPid}) on port ${port}`);
+    // Signal the bin.ts wrapper, not only the child: killing just the child
+    // looks like a crash and the old wrapper respawns it, which then evicts us.
+    // The wrapper forwards SIGTERM and does not restart after it.
+    const wrapperPid = body.wrapperPid && body.wrapperPid !== process.ppid
+        ? body.wrapperPid
+        : null;
+    hranaLogger.log(`Evicting existing kimaki process (PID: ${targetPid}, wrapper: ${wrapperPid ?? 'none'}) on port ${port}`);
     const killResult = errore.try(() => {
-        process.kill(targetPid, 'SIGTERM');
+        process.kill(wrapperPid ?? targetPid, 'SIGTERM');
     }, (e) => new Error('Failed to send SIGTERM to existing kimaki process', {
         cause: e,
     }));
@@ -252,17 +262,61 @@ export async function evictExistingInstance({ port }) {
         hranaLogger.log(`Failed to kill PID ${targetPid}: ${killResult.message}`);
         return;
     }
-    for (let attempt = 0; attempt < 10; attempt += 1) {
+    // Wait for process exit, not just a failed probe: a process that already
+    // closed its HTTP server can still be alive and holding the socket briefly.
+    if (await waitForProcessExit({ pid: targetPid, timeoutMs: gracePeriodMs })) {
+        return;
+    }
+    hranaLogger.log(`PID ${targetPid} still alive after ${gracePeriodMs / 1000}s SIGTERM grace period, sending SIGKILL`);
+    // Wrapper first so it cannot respawn the child we are about to kill.
+    const wrapperKillResult = wrapperPid
+        ? errore.try(() => {
+            process.kill(wrapperPid, 'SIGKILL');
+        }, (e) => new Error('Failed to send SIGKILL to kimaki wrapper', { cause: e }))
+        : null;
+    if (wrapperKillResult instanceof Error) {
+        hranaLogger.log(`Failed to kill wrapper PID ${wrapperPid}: ${wrapperKillResult.message}`);
+    }
+    const forceKillResult = errore.try(() => {
+        process.kill(targetPid, 'SIGKILL');
+    }, (e) => new Error('Failed to send SIGKILL to existing kimaki process', {
+        cause: e,
+    }));
+    if (forceKillResult instanceof Error) {
+        hranaLogger.log(`Failed to kill PID ${targetPid}: ${forceKillResult.message}`);
+        return;
+    }
+    if (await waitForProcessExit({ pid: targetPid, timeoutMs: 5_000 })) {
+        return;
+    }
+    hranaLogger.log(`PID ${targetPid} still alive after SIGKILL`);
+}
+// PID of the bin.ts respawn wrapper, only while it is alive (IPC connected).
+// Without the connected check an orphan would report ppid 1.
+function getWrapperPid() {
+    if (!process.env.__KIMAKI_CHILD || !process.connected) {
+        return null;
+    }
+    return process.ppid;
+}
+function isProcessAlive(pid) {
+    const result = errore.try(() => {
+        process.kill(pid, 0);
+    }, (e) => new Error('Process liveness check failed', { cause: e }));
+    if (result instanceof Error) {
+        // EPERM means the PID exists but belongs to another user.
+        return result.cause instanceof Error && Reflect.get(result.cause, 'code') === 'EPERM';
+    }
+    return true;
+}
+async function waitForProcessExit({ pid, timeoutMs, }) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!isProcessAlive(pid))
+            return true;
         await new Promise((resolve) => {
-            setTimeout(resolve, 1000);
+            setTimeout(resolve, 200);
         });
-        // Verify it's gone. Some shutdown paths need a few seconds to run cleanup,
-        // so we avoid SIGKILL and just poll for up to 10 seconds.
-        const secondProbe = await fetch(url, {
-            signal: AbortSignal.timeout(2000),
-        }).catch((e) => new FetchError({ url, cause: e }));
-        if (secondProbe instanceof Error)
-            return;
     }
-    hranaLogger.log(`PID ${targetPid} still alive after 10s SIGTERM grace period`);
+    return !isProcessAlive(pid);
 }

package/dist/markdown.js

@@ -15,6 +15,112 @@ class UnexpectedError extends errore.createTaggedError({
 }
 const markdownLogger = createLogger(LogPrefix.MARKDOWN);
 const TOOL_OUTPUT_MAX_CHARS = 30_000;
+export const DEFAULT_TOOL_INPUT_MAX_CHARS = 80;
+function stringifyToolValue(value) {
+    if (typeof value === 'string')
+        return value;
+    return JSON.stringify(value);
+}
+export function truncateChars(value, maxChars) {
+    const collapsed = value.replace(/\s+/g, ' ').trim();
+    if (maxChars <= 0)
+        return '';
+    if (collapsed.length <= maxChars)
+        return collapsed;
+    if (maxChars === 1)
+        return '…';
+    return `${collapsed.slice(0, maxChars - 1)}…`;
+}
+export function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60_000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    const minutes = Math.floor(ms / 60_000);
+    const seconds = Math.floor((ms % 60_000) / 1000);
+    return `${minutes}m ${seconds}s`;
+}
+function messageCreatedAt(message) {
+    const created = message.time?.created;
+    return typeof created === 'number' ? created : undefined;
+}
+function messageEndedAt(message) {
+    const completed = message.time?.completed;
+    if (typeof completed === 'number')
+        return completed;
+    return messageCreatedAt(message);
+}
+/** User sent → last assistant finished, until the next user message. */
+export function userPromptDurationMs({ messages, userIndex, }) {
+    const userCreated = messageCreatedAt(messages[userIndex]?.info ?? {});
+    if (userCreated === undefined)
+        return undefined;
+    let end = userCreated;
+    for (let i = userIndex + 1; i < messages.length; i++) {
+        const info = messages[i]?.info;
+        if (info?.role === 'user')
+            break;
+        if (info?.role !== 'assistant')
+            continue;
+        const ended = messageEndedAt(info);
+        if (ended !== undefined && ended > end)
+            end = ended;
+    }
+    const ms = end - userCreated;
+    return ms > 0 ? ms : undefined;
+}
+export function fileBaseName(filePath) {
+    const normalized = filePath.replaceAll('\\', '/');
+    const segments = normalized.split('/');
+    return segments[segments.length - 1] || filePath;
+}
+function readTaskSessionId(metadata) {
+    if (!metadata || typeof metadata !== 'object' || Array.isArray(metadata))
+        return undefined;
+    const sessionId = metadata.sessionId;
+    return typeof sessionId === 'string' && sessionId.length > 0 ? sessionId : undefined;
+}
+function taskChildSessionId({ input, metadata, }) {
+    const sessionId = readTaskSessionId(metadata);
+    if (sessionId)
+        return sessionId;
+    const taskId = input?.task_id;
+    if (typeof taskId === 'string' && taskId.startsWith('ses'))
+        return taskId;
+    return undefined;
+}
+/** Compact tool input for session markdown. Keep this greppable and short. */
+export function formatCompactToolSummary({ tool, input, maxChars = DEFAULT_TOOL_INPUT_MAX_CHARS, metadata, }) {
+    const record = input ?? {};
+    if (tool === 'read') {
+        const path = record.filePath ?? record.path;
+        return typeof path === 'string' && path.length > 0 ? fileBaseName(path) : '';
+    }
+    if (tool === 'task') {
+        const description = typeof record.description === 'string' ? record.description : '';
+        const sessionId = taskChildSessionId({ input: record, metadata });
+        if (!sessionId)
+            return truncateChars(description, maxChars);
+        const separator = description.trim() ? 1 : 0;
+        const descBudget = Math.max(0, maxChars - sessionId.length - separator);
+        const desc = truncateChars(description, descBudget);
+        return [desc, sessionId].filter(Boolean).join(' ');
+    }
+    if (tool === 'bash') {
+        const command = typeof record.command === 'string' ? record.command : '';
+        const collapsedCommand = command.replace(/\s+/g, ' ').trim();
+        if (collapsedCommand.length > 0 && collapsedCommand.length <= maxChars) {
+            return collapsedCommand;
+        }
+        const description = typeof record.description === 'string' ? record.description : '';
+        return truncateChars(description || collapsedCommand, maxChars);
+    }
+    const parts = [];
+    for (const [key, value] of Object.entries(record)) {
+        parts.push(`${key}=${stringifyToolValue(value)}`);
+    }
+    return truncateChars(parts.join(' '), maxChars);
+}
 export class ShareMarkdown {
     client;
     constructor(client) {
@@ -26,7 +132,7 @@ export class ShareMarkdown {
      * @returns Error or markdown string
      */
     async generate(options) {
-        const { sessionID, includeSystemInfo, lastAssistantOnly, compactTools = true } = options;
+        const { sessionID, includeSystemInfo, lastAssistantOnly, compactTools = true, includeThinking = false, toolInputMaxChars = DEFAULT_TOOL_INPUT_MAX_CHARS, } = options;
         // Get session info
         const sessionResponse = await this.client.session.get({
             sessionID,
@@ -45,12 +151,7 @@ export class ShareMarkdown {
         const messages = messagesResponse.data;
         // If lastAssistantOnly, filter to only the last assistant message
         const messagesToRender = lastAssistantOnly
-            ? (() => {
-                const assistantMessages = messages.filter((m) => m.info.role === 'assistant');
-                return assistantMessages.length > 0
-                    ? [assistantMessages[assistantMessages.length - 1]]
-                    : [];
-            })()
+            ? messages.filter((m) => m.info.role === 'assistant').slice(-1)
             : messages;
         // Build markdown
         const lines = [];
@@ -74,17 +175,37 @@ export class ShareMarkdown {
             lines.push('## Conversation');
             lines.push('');
         }
-        for (const message of messagesToRender) {
-            const messageLines = this.renderMessage(message.info, message.parts, { compactTools });
+        for (const [index, message] of messagesToRender.entries()) {
+            const messageLines = this.renderMessage(message.info, message.parts, {
+                compactTools,
+                includeThinking,
+                toolInputMaxChars,
+            });
             lines.push(...messageLines);
             lines.push('');
+            const nextRole = messagesToRender[index + 1]?.info.role;
+            if (message.info.role !== 'assistant' || nextRole === 'assistant')
+                continue;
+            for (let userIndex = index - 1; userIndex >= 0; userIndex--) {
+                if (messagesToRender[userIndex]?.info.role !== 'user')
+                    continue;
+                const durationMs = userPromptDurationMs({
+                    messages: messagesToRender,
+                    userIndex,
+                });
+                if (durationMs !== undefined) {
+                    lines.push(`duration: ${formatDuration(durationMs)}`);
+                    lines.push('');
+                }
+                break;
+            }
         }
         return lines.join('\n');
     }
     renderMessage(message, parts, opts) {
         const lines = [];
         if (message.role === 'user') {
-            lines.push('### 👤 User');
+            lines.push('### user');
             lines.push('');
             for (const part of parts) {
                 if (part.type === 'text' && part.text) {
@@ -95,7 +216,7 @@ export class ShareMarkdown {
                     }
                 }
                 else if (part.type === 'file') {
-                    lines.push(`📎 **Attachment**: ${part.filename || 'unnamed file'}`);
+                    lines.push(`file: ${part.filename || 'unnamed file'}`);
                     if (part.url) {
                         lines.push(`   - URL: ${part.url}`);
                     }
@@ -104,47 +225,38 @@ export class ShareMarkdown {
             }
         }
         else if (message.role === 'assistant') {
-            const modelId = [message.providerID, message.modelID].filter(Boolean).join('/') ||
-                'unknown model';
-            lines.push(`### 🤖 Assistant (${modelId})`);
-            lines.push('');
-            // Filter and process parts
             const filteredParts = parts.filter((part) => {
-                if (part.type === 'step-start' && parts.indexOf(part) > 0)
-                    return false;
-                if (part.type === 'snapshot')
-                    return false;
-                if (part.type === 'patch')
+                if (part.type === 'step-start' ||
+                    part.type === 'step-finish' ||
+                    part.type === 'snapshot' ||
+                    part.type === 'patch')
                     return false;
-                if (part.type === 'step-finish')
-                    return false;
-                if (part.type === 'text' && part.synthetic === true)
+                if (part.type === 'text' && (part.synthetic === true || !part.text))
                     return false;
                 if (part.type === 'tool' && part.tool === 'todoread')
                     return false;
-                if (part.type === 'text' && !part.text)
-                    return false;
                 if (part.type === 'tool' &&
                     (part.state.status === 'pending' || part.state.status === 'running'))
                     return false;
                 return true;
             });
+            const body = [];
             for (const part of filteredParts) {
-                const partLines = opts.compactTools
-                    ? this.renderPartCompact(part, message)
-                    : this.renderPart(part, message);
-                lines.push(...partLines);
-            }
-            // Add completion time if available
-            if (message.time?.completed) {
-                const duration = message.time.completed - message.time.created;
-                lines.push('');
-                lines.push(`*Completed in ${this.formatDuration(duration)}*`);
+                body.push(...(opts.compactTools
+                    ? this.renderPartCompact(part, opts)
+                    : this.renderPart(part, opts)));
             }
+            if (body.length === 0)
+                return lines;
+            const modelId = [message.providerID, message.modelID].filter(Boolean).join('/') ||
+                'unknown model';
+            lines.push(`### assistant (${modelId})`);
+            lines.push('');
+            lines.push(...body);
         }
         return lines;
     }
-    renderPart(part, message) {
+    renderPart(part, opts) {
         const lines = [];
         switch (part.type) {
             case 'text':
@@ -154,14 +266,11 @@ export class ShareMarkdown {
                 }
                 break;
             case 'reasoning':
-                if (part.text) {
-                    lines.push('<details>');
-                    lines.push('<summary>💭 Thinking</summary>');
+                if (opts.includeThinking && part.text) {
+                    lines.push('thinking:');
                     lines.push('');
                     lines.push(part.text);
                     lines.push('');
-                    lines.push('</details>');
-                    lines.push('');
                 }
                 break;
             case 'tool':
@@ -169,10 +278,10 @@ export class ShareMarkdown {
                     const output = part.state.output || '';
                     const isOversized = output.length > TOOL_OUTPUT_MAX_CHARS;
                     if (isOversized) {
-                        lines.push(`> ⚠️ **Large tool output** (${output.length.toLocaleString()} chars, truncated to ${TOOL_OUTPUT_MAX_CHARS.toLocaleString()})`);
+                        lines.push(`> Large tool output (${output.length.toLocaleString()} chars, truncated to ${TOOL_OUTPUT_MAX_CHARS.toLocaleString()})`);
                         lines.push('');
                     }
-                    lines.push(`#### 🛠️ Tool: ${part.tool}`);
+                    lines.push(`#### tool: ${part.tool}`);
                     lines.push('');
                     // Render input parameters in YAML
                     if (part.state.input && Object.keys(part.state.input).length > 0) {
@@ -193,17 +302,9 @@ export class ShareMarkdown {
                         lines.push('```');
                         lines.push('');
                     }
-                    // Add timing info if significant
-                    if (part.state.time?.start && part.state.time?.end) {
-                        const duration = part.state.time.end - part.state.time.start;
-                        if (duration > 2000) {
-                            lines.push(`*Duration: ${this.formatDuration(duration)}*`);
-                            lines.push('');
-                        }
-                    }
                 }
                 else if (part.state.status === 'error') {
-                    lines.push(`#### ❌ Tool Error: ${part.tool}`);
+                    lines.push(`#### tool-error: ${part.tool}`);
                     lines.push('');
                     lines.push('```');
                     lines.push(part.state.error || 'Unknown error');
@@ -211,75 +312,36 @@ export class ShareMarkdown {
                     lines.push('');
                 }
                 break;
-            case 'step-start':
-                lines.push(`**Started using ${message.providerID}/${message.modelID}**`);
-                lines.push('');
-                break;
         }
         return lines;
     }
     /** Compact rendering: tool calls become a single line with line count instead of full output. */
-    renderPartCompact(part, message) {
-        // Non-tool parts render the same as verbose
+    renderPartCompact(part, opts) {
         if (part.type !== 'tool') {
-            return this.renderPart(part, message);
+            return this.renderPart(part, opts);
         }
         const lines = [];
         if (part.state.status === 'completed') {
             const output = part.state.output || '';
             const lineCount = output ? output.split('\n').length : 0;
-            const inputSummary = this.compactInputSummary(part.state.input);
+            const inputSummary = formatCompactToolSummary({
+                tool: part.tool,
+                input: part.state.input,
+                maxChars: opts.toolInputMaxChars,
+                metadata: part.state.metadata,
+            });
             const outputLabel = lineCount > 0 ? `(${lineCount} lines)` : '';
             const parts = [inputSummary, outputLabel].filter(Boolean).join(' ');
-            lines.push(`> 🛠️ **${part.tool}**${parts ? ` ${parts}` : ''}`);
+            lines.push(`tool: ${part.tool}${parts ? ` ${parts}` : ''}`);
             lines.push('');
         }
         else if (part.state.status === 'error') {
             const errorText = (part.state.error || 'Unknown error').split('\n')[0].slice(0, 120);
-            lines.push(`> ❌ **${part.tool}** — ${errorText}`);
+            lines.push(`tool-error: ${part.tool} ${errorText}`);
             lines.push('');
         }
         return lines;
     }
-    /** Build a compact key=value summary of tool input, max 2 params, 80 chars each. */
-    compactInputSummary(input) {
-        if (!input)
-            return '';
-        const entries = Object.entries(input);
-        if (entries.length === 0)
-            return '';
-        const parts = [];
-        const maxParams = 2;
-        for (let i = 0; i < Math.min(entries.length, maxParams); i++) {
-            const [key, value] = entries[i];
-            let val;
-            try {
-                val = typeof value === 'string'
-                    ? value
-                    : (JSON.stringify(value) ?? String(value));
-            }
-            catch {
-                val = String(value);
-            }
-            // Collapse whitespace for readability
-            const collapsed = val.replace(/\s+/g, ' ').trim();
-            const normalized = collapsed.length > 80 ? `${collapsed.slice(0, 80)}…` : collapsed;
-            parts.push(`${key}=${normalized}`);
-        }
-        if (entries.length > maxParams) {
-            parts.push('...');
-        }
-        return parts.join(', ');
-    }
-    formatDuration(ms) {
-        if (ms < 1000)
-            return `${ms}ms`;
-        if (ms < 60000)
-            return `${(ms / 1000).toFixed(1)}s`;
-        const minutes = Math.floor(ms / 60000);
-        const seconds = Math.floor((ms % 60000) / 1000);
-        return `${minutes}m ${seconds}s`;
-    }
 }
 /**
  * Generate compact session context for voice transcription.