kimaki 0.4.83 → 0.4.85

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

@@ -0,0 +1,117 @@
+// E2e test: queued message must drain after the user answers a pending question
+// via the Discord dropdown select menu. Reproduces a bug where answering via
+// select (not text) leaves queued messages stuck because the session continues
+// processing after the answer and may enter another blocking state.
+import { describe, test, expect } from 'vitest';
+import { setupQueueAdvancedSuite, TEST_USER_ID, } from './queue-advanced-e2e-setup.js';
+import { waitForBotMessageContaining, waitForFooterMessage, } from './test-utils.js';
+import { pendingQuestionContexts } from './commands/ask-question.js';
+const TEXT_CHANNEL_ID = '200000000000001030';
+async function waitForPendingQuestion({ threadId, timeoutMs, }) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        const entry = [...pendingQuestionContexts.entries()].find(([, context]) => {
+            return context.thread.id === threadId;
+        });
+        if (entry) {
+            return { contextHash: entry[0] };
+        }
+        await new Promise((resolve) => {
+            setTimeout(resolve, 100);
+        });
+    }
+    throw new Error('Timed out waiting for pending question context');
+}
+describe('queue drain after question select answer', () => {
+    const ctx = setupQueueAdvancedSuite({
+        channelId: TEXT_CHANNEL_ID,
+        channelName: 'qa-question-select-drain',
+        dirName: 'qa-question-select-drain',
+        username: 'question-select-tester',
+    });
+    test('queued message drains after answering question via dropdown select', async () => {
+        // 1. Send a message that triggers the question tool
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'QUESTION_SELECT_QUEUE_MARKER',
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'QUESTION_SELECT_QUEUE_MARKER';
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        // 2. Wait for the question dropdown to appear
+        const pending = await waitForPendingQuestion({
+            threadId: thread.id,
+            timeoutMs: 4_000,
+        });
+        expect(pending.contextHash).toBeTruthy();
+        // Verify dropdown message appeared
+        const questionMessages = await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            text: 'How to proceed?',
+            timeout: 4_000,
+        });
+        const questionMsg = questionMessages.find((m) => {
+            return m.content.includes('How to proceed?');
+        });
+        expect(questionMsg).toBeTruthy();
+        // 3. Queue a message while question is pending
+        const { id: queueInteractionId } = await th.user(TEST_USER_ID)
+            .runSlashCommand({
+            name: 'queue',
+            options: [{ name: 'message', type: 3, value: 'Reply with exactly: post-question-drain' }],
+        });
+        const queueAck = await th.waitForInteractionAck({
+            interactionId: queueInteractionId,
+            timeout: 4_000,
+        });
+        if (!queueAck.messageId) {
+            throw new Error('Expected /queue response message id');
+        }
+        // 4. Answer the question via dropdown select (pick first option "Alpha")
+        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: 4_000,
+        });
+        // 5. Queued message should be handed off to OpenCode's own prompt queue
+        //    after the question reply, so the dispatch indicator appears without
+        //    waiting for a later natural idle.
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            text: '» **question-select-tester:** Reply with exactly: post-question-drain',
+            timeout: 4_000,
+        });
+        // 6. Wait for footer from the drained queued message
+        await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 4_000,
+            afterMessageIncludes: '» **question-select-tester:**',
+            afterAuthorId: ctx.discord.botUserId,
+        });
+        const timeline = await th.text({ showInteractions: true });
+        expect(timeline).toMatchInlineSnapshot(`
+        "--- from: user (question-select-tester)
+        QUESTION_SELECT_QUEUE_MARKER
+        --- from: assistant (TestBot)
+        **Select action**
+        How to proceed?
+        ✓ _Alpha_
+        [user interaction]
+        Queued message (position 1)
+        [user selects dropdown: 0]
+        » **question-select-tester:** Reply with exactly: post-question-drain
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+      `);
+    }, 20_000);
+});

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

@@ -1805,6 +1805,49 @@ export class ThreadSessionRuntime {
             return;
         }
         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.
+        if (this.getQueueLength() > 0 && !this.questionReplyQueueHandoffPromise) {
+            logger.log(`[QUESTION REPLIED] Queue has ${this.getQueueLength()} items, handing off to opencode queue`);
+            this.questionReplyQueueHandoffPromise = this.handoffQueuedItemsAfterQuestionReply({
+                sessionId,
+            }).catch((error) => {
+                logger.error('[QUESTION REPLIED] Failed to hand off queued messages:', error);
+                if (error instanceof Error) {
+                    void notifyError(error, 'Failed to hand off queued messages after question reply');
+                }
+            }).finally(() => {
+                this.questionReplyQueueHandoffPromise = null;
+            });
+        }
+    }
+    // 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.
+    questionReplyQueueHandoffPromise = null;
+    async handoffQueuedItemsAfterQuestionReply({ sessionId, }) {
+        if (this.listenerAborted) {
+            return;
+        }
+        if (this.state?.sessionId !== sessionId) {
+            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);
+        }
     }
     async handleSessionStatus(properties) {
         const sessionId = this.state?.sessionId;
@@ -2624,12 +2667,18 @@ export class ThreadSessionRuntime {
         if (input.command) {
             const queuedCommand = input.command;
             const commandSignal = AbortSignal.timeout(30_000);
+            // session.command() only accepts FilePart in parts, not text parts.
+            // Append <discord-user /> tag to arguments so external sync can
+            // detect this message came from Discord (same tag as promptAsync).
+            const discordTag = input.username
+                ? `\n<discord-user name="${input.username}" />`
+                : '';
             const commandResponse = await errore.tryAsync(() => {
                 return getClient().session.command({
                     sessionID: session.id,
                     directory: this.sdkDirectory,
                     command: queuedCommand.name,
-                    arguments: queuedCommand.arguments,
+                    arguments: queuedCommand.arguments + discordTag,
                     agent: earlyAgentPreference,
                     ...variantField,
                 }, { signal: commandSignal });

package/dist/store.js

@@ -5,6 +5,7 @@
 import { createStore } from 'zustand/vanilla';
 export const store = createStore(() => ({
     dataDir: null,
+    projectsDir: null,
     defaultVerbosity: 'text_and_essential_tools',
     defaultMentionMode: false,
     critiqueEnabled: true,

package/dist/system-message.js

@@ -54,6 +54,18 @@ bunx critique --web "Short title describing the changes" --filter "src/config.ts
 
 The string after \`--web\` becomes the diff page title — make it reflect what the changes do (e.g. "Add retry logic to API client", "Fix auth timeout bug").
 
+### fetching user comments from critique diffs
+
+Users can add line-level comments (annotations) on any critique diff page via the Agentation widget (bottom-right corner of the diff page). To read those comments:
+
+\`\`\`bash
+curl https://critique.work/v/<id>/annotations
+\`\`\`
+
+Returns \`text/markdown\` with each annotation showing the file, line, and comment text.
+Use this when the user says they left comments on a critique diff and you need to read them.
+You can also use WebFetch on \`https://critique.work/v/<id>/annotations\` to get the markdown directly.
+
 ### about critique
 
 critique is an open source tool (MIT license) at https://github.com/remorses/critique.
@@ -131,7 +143,7 @@ Use random tunnel IDs by default. Only pass \`-t\` when exposing a service that
 tmux new-session -d -s myapp-dev
 
 # Run the dev server with kimaki tunnel inside the session
-tmux send-keys -t myapp-dev "kimaki tunnel -p 3000 -- pnpm dev" Enter
+tmux send-keys -t myapp-dev "kimaki tunnel --kill -p 3000 -- pnpm dev" Enter
 \`\`\`
 
 ### getting the tunnel URL
@@ -146,15 +158,15 @@ tmux capture-pane -t myapp-dev -p | grep -i "tunnel"
 \`\`\`bash
 # Next.js project
 tmux new-session -d -s projectname-nextjs-dev-3000
-tmux send-keys -t nextjs-dev "kimaki tunnel -p 3000 -- pnpm dev" Enter
+tmux send-keys -t nextjs-dev "kimaki tunnel --kill -p 3000 -- pnpm dev" Enter
 
 # Vite project on port 5173
 tmux new-session -d -s vite-dev-5173
-tmux send-keys -t vite-dev "kimaki tunnel -p 5173 -- pnpm dev" Enter
+tmux send-keys -t vite-dev "kimaki tunnel --kill -p 5173 -- pnpm dev" Enter
 
 # Custom tunnel ID (only for intentionally public-safe services)
 tmux new-session -d -s holocron-dev
-tmux send-keys -t holocron-dev "kimaki tunnel -p 3000 -t holocron -- pnpm dev" Enter
+tmux send-keys -t holocron-dev "kimaki tunnel --kill -p 3000 -t holocron -- pnpm dev" Enter
 \`\`\`
 
 ### stopping the dev server

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.83",
+  "version": "0.4.85",
   "repository": "https://github.com/remorses/kimaki",
   "bin": "bin.js",
   "files": [
@@ -25,8 +25,8 @@
     "prisma": "7.4.2",
     "tsx": "^4.20.5",
     "discord-digital-twin": "^0.1.0",
-    "opencode-cached-provider": "^0.0.1",
     "opencode-deterministic-provider": "^0.0.1",
+    "opencode-cached-provider": "^0.0.1",
     "db": "^0.0.0"
   },
   "dependencies": {
@@ -67,8 +67,8 @@
     "zod": "^4.3.6",
     "zustand": "^5.0.11",
     "errore": "^0.14.1",
-    "traforo": "^0.1.0",
-    "libsqlproxy": "^0.1.0"
+    "libsqlproxy": "^0.1.0",
+    "traforo": "^0.2.0"
   },
   "optionalDependencies": {
     "@discordjs/opus": "^0.10.0",
@@ -79,6 +79,7 @@
   },
   "scripts": {
     "dev": "tsx src/cli.ts",
+    "build": "pnpm generate && pnpm tsc",
     "dev:bun": "DEBUG=1 bun --env-file .env src/cli.ts",
     "watch": "tsx scripts/watch-session.ts",
     "generate": "prisma generate && pnpm generate:sql",

package/skills/errore/SKILL.md

@@ -432,11 +432,11 @@ return res.status(response.status).json(response.body)
 
 > `matchError` routes by `_tag` and requires an `Error` fallback for plain Error instances. Use `matchErrorPartial` when you only need to handle some cases.
 
-### Resource Cleanup (defer)
+### Resource Cleanup (defer) — Replacing try/finally with `using`
 
-errore ships `DisposableStack` and `AsyncDisposableStack` polyfills that work in every runtime. Use them with TypeScript's `using` / `await using` for Go-like `defer` cleanup.
+`try/finally` has a structural problem: **every resource adds a nesting level**. Two resources = two levels of indentation. The business logic gets buried deeper with each resource, and cleanup is split across `finally` blocks far from where the resource was acquired. `await using` + `DisposableStack` keeps the function flat — one `cleanup.defer()` per resource, same indentation whether you have one resource or ten. Cleanup runs automatically in reverse order on every exit path.
 
-**tsconfig requirement:** add `"ESNext.Disposable"` to `lib` so TypeScript knows about `Disposable`, `AsyncDisposable`, `using`, and `await using`:
+**tsconfig requirement:** add `"ESNext.Disposable"` to `lib`:
 
 ```jsonc
 {
@@ -446,28 +446,51 @@ errore ships `DisposableStack` and `AsyncDisposableStack` polyfills that work in
 }
 ```
 
-Without this, `using`/`await using` declarations and `Symbol.dispose`/`Symbol.asyncDispose` will produce type errors. The errore polyfill handles the runtime side — this setting handles the type side.
+**Before — nested try/finally:**
 
 ```ts
-import * as errore from 'errore'
+async function importData(url: string, dbUrl: string) {
+  const db = await connectDb(dbUrl)
+  try {
+    const tmpFile = await createTempFile()
+    try {
+      const data = await (await fetch(url)).text()
+      await tmpFile.write(data)
+      await db.import(tmpFile.path)
+      return { rows: await db.count() }
+    } finally {
+      await tmpFile.delete()
+    }
+  } finally {
+    await db.close()
+  }
+}
+```
+
+**After — flat with `await using`:**
 
-async function processRequest(id: string): Promise<DbError | Result> {
+```ts
+async function importData(url: string, dbUrl: string): Promise<ImportError | { rows: number }> {
   await using cleanup = new errore.AsyncDisposableStack()
 
-  const db = await connectDb().catch((e) => new DbError({ cause: e }))
+  const db = await connectDb(dbUrl).catch((e) => new ImportError({ reason: 'db connect', cause: e }))
   if (db instanceof Error) return db
   cleanup.defer(() => db.close())
 
-  const cache = await openCache().catch((e) => new CacheError({ cause: e }))
-  if (cache instanceof Error) return cache
-  cleanup.defer(() => cache.flush())
+  const tmpFile = await createTempFile()
+  cleanup.defer(() => tmpFile.delete())
+
+  const response = await fetch(url).catch((e) => new ImportError({ reason: 'fetch', cause: e }))
+  if (response instanceof Error) return response
 
-  return result
-  // cleanup runs in LIFO order: cache.flush(), then db.close()
+  await tmpFile.write(await response.text())
+  await db.import(tmpFile.path)
+  return { rows: await db.count() }
+  // cleanup: tmpFile.delete() → db.close()
 }
 ```
 
-> `await using` guarantees cleanup runs when the scope exits — whether by return, early error return, or thrown exception. Resources are released in reverse order (LIFO), just like Go's `defer`. No `try/finally` nesting.
+> `await using` guarantees cleanup on every exit path — normal return, early error return, or exception. Resources release in LIFO order. Adding a resource is one line (`cleanup.defer()`), not another nesting level. The errore polyfill handles the runtime; the tsconfig `lib` entry handles the types.
 
 ### Fallback Values
 
@@ -608,6 +631,10 @@ for (const item of items) {
 
 > Place `signal.aborted` checks **before** expensive operations (network, db writes, file I/O). Check `isAbortError` **after** async calls that received the signal. Both keep the function responsive to cancellation.
 
+## Linting
+
+If the project uses [lintcn](https://github.com/remorses/lintcn), read `docs/lintcn.md` for the `no-unhandled-error` rule that catches discarded `Error | T` return values.
+
 ## Pitfalls
 
 ### CustomError | Error is ambiguous when CustomError extends Error

package/skills/goke/SKILL.md

@@ -602,6 +602,18 @@ cli.version('1.0.0')
 cli.parse()
 ```
 
+## `openInBrowser(url)`
+
+Opens a URL in the default browser. In non-TTY environments (CI, piped output, agents), prints the URL to stdout instead of opening a browser.
+
+```ts
+import { openInBrowser } from 'goke'
+
+openInBrowser('https://example.com/dashboard')
+```
+
+Use this after generating URLs (OAuth callbacks, dashboards, docs links) so interactive users get a browser tab and non-interactive environments get a printable URL.
+
 ## Exposing your CLI as a skill
 
 When you build a CLI with goke, the optimal way to create a skill for it is a minimal SKILL.md that tells agents to run `--help` before using the CLI. This way descriptions, examples, and usage patterns live in the CLI code (collocated with the implementation) instead of a separate markdown file that can go stale.