kimaki 0.25.0 → 0.26.0

package/skills/profano/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: profano
-description: CLI tool to analyze V8 .cpuprofile files and print top functions by self-time or total-time in the terminal. ALWAYS load this skill when CPU profiling JavaScript or TypeScript programs (Node, Vitest, Bun, Chrome DevTools exports) — it shows how to generate .cpuprofile files and how to inspect them from the terminal without opening Chrome DevTools.
+description: CLI tool to analyze V8 .cpuprofile files and Chrome Performance traces and print top functions by self-time or total-time in the terminal. ALWAYS load this skill when CPU profiling JavaScript or TypeScript programs (Node, Vitest, Bun, Chrome DevTools exports) — it shows how to generate .cpuprofile files and how to inspect them from the terminal without opening Chrome DevTools.
 ---
 
 # profano
 
-`profano` reads V8 `.cpuprofile` files and prints the heaviest functions as a table sorted by self-time or total (inclusive) time.
+`profano` reads V8 `.cpuprofile` files and Chrome Performance traces (`Trace-*.json`) and prints the heaviest functions as a table sorted by self-time or total (inclusive) time.
 
 Every time you use profano, you MUST fetch the latest README and read it in full:
 
@@ -13,4 +13,6 @@ Every time you use profano, you MUST fetch the latest README and read it in full
 curl -s https://raw.githubusercontent.com/remorses/profano/main/README.md  # NEVER pipe to head/tail, read in full
 ```
 
-The README covers generating `.cpuprofile` files (Node, Vitest, Bun, Chrome DevTools, browser pages via playwriter, React component profiling), all CLI options, and how to read the output columns.
+The README covers generating `.cpuprofile` files (Node, Vitest, Bun, Chrome Performance traces, browser pages via playwriter, React component profiling), all CLI options, and how to read the output columns.
+
+Chrome Performance **Save profile** writes a trace JSON. Pass it to `profano Trace.json` directly. Do not convert it first.

package/skills/spiceflow/SKILL.md

@@ -1,10 +1,27 @@
 ---
 name: spiceflow
-description: 'Spiceflow is a super simple, fast, and type-safe API and React Server Components framework for TypeScript. Works on Node.js, Bun, and Cloudflare Workers. Use this skill whenever working with spiceflow to get the latest docs and API reference.'
+description: 'Spiceflow is a super simple, fast, and type-safe API and React Server Components framework for TypeScript. Works on Node.js, Bun, and Cloudflare Workers. ALWAYS load this skill BEFORE writing or editing ANY spiceflow code, including one-line changes: routes, pages, layouts, loaders, server actions, forms, ErrorBoundary, redirects, cookies, navigation, Link, router, ProgressBar, the typed fetch client, middleware, and OpenAPI. A project uses spiceflow if anything imports from "spiceflow" or "spiceflow/react", or constructs new Spiceflow(). The API is small but very opinionated and the opinions are NOT guessable; writing spiceflow code from memory or from what looks like Next.js produces wrong code every time.'
 ---
 
 # Spiceflow
 
+## When to load this skill
+
+**ALWAYS, before you touch ANY spiceflow code.** Not "when stuck", not "for big changes", not "if the task looks unusual" — every single time, including one-line edits.
+
+A project uses spiceflow if anything imports from `spiceflow` or `spiceflow/react`, or constructs `new Spiceflow()`. That covers:
+
+- routes (`.get`, `.post`, `.route`), pages, layouts, loaders
+- server actions, forms, `ErrorBoundary`, `parseFormData`, `useActionState`
+- redirects, cookies, navigation, `Link`, `router`, `ProgressBar`
+- the typed fetch client, middleware, tracing, OpenAPI
+
+The API surface is small but **very opinionated**, and the opinions are NOT guessable. Every framework has its own answer for forms, pending state, error display, and redirects; spiceflow's answers are frequently different from Next.js and from React defaults. Writing spiceflow code from memory, or from what "looks like Next.js", produces wrong code every time.
+
+If you already started editing spiceflow code without loading this skill, stop, load it, read the README, and re-check what you wrote.
+
+## Read the full README first
+
 Every time you work with spiceflow, you MUST fetch the **entire** README from the main branch. The README is the primary documentation and every section matters. You MUST read it completely, from start to finish, with no truncation. Partial reads cause you to miss critical API details, conventions, and patterns that lead to wrong implementations.
 
 ```bash
@@ -133,6 +150,12 @@ export async function deleteProject(id: string) {
 
 Never assume a server action is only reachable through your own UI. Treat every server action like a public API endpoint.
 
+## Never `router.refresh()` after server actions
+
+Successful server actions re-run matching loaders and reconcile the current page. Do not call `router.refresh()` afterward. Use it only when data changes outside a server action.
+
+`router.refresh()` is fire-and-forget. Do not await a custom refresh or navigation commit helper inside a React form action because the transition can deadlock.
+
 ## Router usage in app entry handlers
 
 `router` from `spiceflow/react` is typed from the globally registered `typeof app`. Do **not** use `router` inside `.loader()`, `.get()`, `.post()`, or `.route()` handlers in the same file that initializes `export const app = new Spiceflow()`. Those handlers feed return types back into `typeof app` through loader data or typed API responses, so `router.href()` can create recursive circular TypeScript errors such as TS7022.

package/src/agent-model.e2e.test.ts

@@ -237,13 +237,13 @@ function createAgentFile({
 }: {
   projectDirectory: string
   agentName: string
-  model: string
+  model?: string
 }) {
   const agentDir = path.join(projectDirectory, '.opencode', 'agent')
   fs.mkdirSync(agentDir, { recursive: true })
   const content = [
     '---',
-    `model: ${model}`,
+    ...(model ? [`model: ${model}`] : []),
     'mode: primary',
     `description: Test agent with custom model`,
     '---',
@@ -369,6 +369,10 @@ describe('agent model resolution', () => {
       agentName: 'plan',
       model: `${PROVIDER_NAME}/${PLAN_AGENT_MODEL}`,
     })
+    createAgentFile({
+      projectDirectory: directories.projectDirectory,
+      agentName: 'plain',
+    })
 
     const dbPath = path.join(directories.dataDir, 'discord-sessions.db')
     const hranaResult = await startHranaServer({ dbPath })
@@ -395,7 +399,7 @@ describe('agent model resolution', () => {
 
     // Register quick agent slash commands so /plan-agent and /test-agent-agent
     // are resolvable by handleQuickAgentCommand via guild.commands.fetch().
-    const agentCommands = ['test-agent', 'plan'].map((agentName) => {
+    const agentCommands = ['test-agent', 'plan', 'plain'].map((agentName) => {
       return new SlashCommandBuilder()
         .setName(`${agentName}-agent`)
         .setDescription(
@@ -1252,7 +1256,7 @@ describe('agent model resolution', () => {
         ⬥ ok
         *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
         Switched to **plan** agent for this session (was **test-agent**)
-        Model: *deterministic-provider/plan-model-v2*
+        Model: *deterministic-provider/plan-model-v2* (agent "plan")
         The agent will change on the next message.
         --- from: user (agent-model-tester)
         Reply with exactly: after-switch-msg
@@ -1276,4 +1280,168 @@ describe('agent model resolution', () => {
     },
     20_000,
   )
+
+  test(
+    '/plan-agent on the same agent refreshes a stale session model',
+    async () => {
+      await setChannelAgent(TEXT_CHANNEL_ID, 'plan')
+
+      await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: refresh-agent-model-msg',
+      })
+
+      const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+        timeout: 4_000,
+        predicate: (t) => {
+          return t.name === 'Reply with exactly: refresh-agent-model-msg'
+        },
+      })
+
+      await waitForFooterMessage({
+        discord,
+        threadId: thread.id,
+        timeout: 4_000,
+        afterMessageIncludes: 'ok',
+        afterAuthorId: discord.botUserId,
+      })
+
+      const sessionId = await getThreadSession(thread.id)
+      expect(sessionId).toBeDefined()
+      if (!sessionId) throw new Error('Expected session')
+
+      await setSessionModel({
+        sessionId,
+        modelId: `${PROVIDER_NAME}/${CHANNEL_MODEL}`,
+      })
+
+      const th = discord.thread(thread.id)
+      const { id: interactionId } = await th
+        .user(TEST_USER_ID)
+        .runSlashCommand({ name: 'plan-agent' })
+
+      await th.waitForInteractionAck({ interactionId, timeout: 4_000 })
+
+      expect(await th.text()).toMatchInlineSnapshot(`
+        "--- from: user (agent-model-tester)
+        Reply with exactly: refresh-agent-model-msg
+        --- from: assistant (TestBot)
+        *using deterministic-provider/plan-model-v2 ⋅ plan*
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ plan-model-v2 ⋅ **plan***
+        Using **plan** agent for this session
+        Model: *deterministic-provider/plan-model-v2* (agent "plan")
+        The agent will change on the next message."
+      `)
+      expect(await th.text()).not.toContain('Already using')
+      expect(await getSessionModel(sessionId)).toBeUndefined()
+    },
+    20_000,
+  )
+
+  test(
+    '/plan-agent shows the agent model when a channel model is also set',
+    async () => {
+      await setChannelAgent(TEXT_CHANNEL_ID, 'test-agent')
+      await setChannelModel({
+        channelId: TEXT_CHANNEL_ID,
+        modelId: `${PROVIDER_NAME}/${CHANNEL_MODEL}`,
+      })
+
+      await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: channel-vs-agent-msg',
+      })
+
+      const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+        timeout: 4_000,
+        predicate: (t) => {
+          return t.name === 'Reply with exactly: channel-vs-agent-msg'
+        },
+      })
+
+      await waitForFooterMessage({
+        discord,
+        threadId: thread.id,
+        timeout: 4_000,
+        afterMessageIncludes: 'ok',
+        afterAuthorId: discord.botUserId,
+      })
+
+      const th = discord.thread(thread.id)
+      const { id: interactionId } = await th
+        .user(TEST_USER_ID)
+        .runSlashCommand({ name: 'plan-agent' })
+
+      await th.waitForInteractionAck({ interactionId, timeout: 4_000 })
+
+      const threadText = await th.text()
+      expect(threadText).toMatchInlineSnapshot(`
+        "--- from: user (agent-model-tester)
+        Reply with exactly: channel-vs-agent-msg
+        --- from: assistant (TestBot)
+        *using deterministic-provider/agent-model-v2 ⋅ test-agent*
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ agent-model-v2 ⋅ **test-agent***
+        Switched to **plan** agent for this session (was **test-agent**)
+        Model: *deterministic-provider/plan-model-v2* (agent "plan")
+        The agent will change on the next message."
+      `)
+      expect(threadText).toContain(
+        `Model: *${PROVIDER_NAME}/${PLAN_AGENT_MODEL}* (agent "plan")`,
+      )
+      expect(threadText).not.toContain('channel override')
+    },
+    20_000,
+  )
+
+  test(
+    '/plain-agent tells the user to clear a channel model override',
+    async () => {
+      const db = await getDb()
+      await db.delete(schema.channel_agents).where(orm.eq(schema.channel_agents.channel_id, TEXT_CHANNEL_ID))
+      await setChannelModel({
+        channelId: TEXT_CHANNEL_ID,
+        modelId: `${PROVIDER_NAME}/${CHANNEL_MODEL}`,
+      })
+
+      await discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: plain-agent-override-msg',
+      })
+
+      const thread = await discord.channel(TEXT_CHANNEL_ID).waitForThread({
+        timeout: 4_000,
+        predicate: (t) => {
+          return t.name === 'Reply with exactly: plain-agent-override-msg'
+        },
+      })
+
+      await waitForFooterMessage({
+        discord,
+        threadId: thread.id,
+        timeout: 4_000,
+        afterMessageIncludes: 'ok',
+        afterAuthorId: discord.botUserId,
+      })
+
+      const th = discord.thread(thread.id)
+      const { id: interactionId } = await th
+        .user(TEST_USER_ID)
+        .runSlashCommand({ name: 'plain-agent' })
+
+      await th.waitForInteractionAck({ interactionId, timeout: 4_000 })
+
+      expect(await th.text()).toMatchInlineSnapshot(`
+        "--- from: user (agent-model-tester)
+        Reply with exactly: plain-agent-override-msg
+        --- from: assistant (TestBot)
+        *using deterministic-provider/channel-model-v2*
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ channel-model-v2*
+        Switched to **plain** agent for this session
+        Model: *deterministic-provider/channel-model-v2* (channel override)
+        This model comes from a channel override. Use /model and press Clear override if you want this agent's model.
+        The agent will change on the next message."
+      `)
+    },
+    20_000,
+  )
 })

package/src/analytics.test.ts

@@ -118,7 +118,7 @@ describe('analytics', () => {
     })
   })
 
-  it('emits project_registered session_created turn_completed shapes', () => {
+  it('emits project_registered session_created turn_completed tokens_used shapes', () => {
     const captured = _enableAnalyticsTestCapture({
       installId: '33333333-3333-4333-8333-333333333333',
       botMode: 'self_hosted',
@@ -136,11 +136,25 @@ describe('analytics', () => {
     trackEvent('turn_completed', {
       duration_sec: 42,
     })
+    trackEvent('tokens_used', {
+      tokens_input: 100,
+      tokens_output: 20,
+      tokens_reasoning: 5,
+      tokens_cache_read: 10,
+      tokens_cache_write: 2,
+      tokens_total: 137,
+      cost: 0,
+      assistant_message_count: 2,
+      is_subagent: false,
+      model: 'gpt-5.3-codex',
+      provider: 'openai',
+    })
 
     expect(captured.map((e) => e.name)).toEqual([
       'project_registered',
       'session_created',
       'turn_completed',
+      'tokens_used',
     ])
     expect(captured[0]!.properties).toMatchObject({
       project_kind: 'user',
@@ -156,5 +170,20 @@ describe('analytics', () => {
     expect(captured[2]!.properties).toMatchObject({
       duration_sec: 42,
     })
+    expect(captured[3]!.properties).toMatchObject({
+      tokens_input: 100,
+      tokens_output: 20,
+      tokens_reasoning: 5,
+      tokens_cache_read: 10,
+      tokens_cache_write: 2,
+      tokens_total: 137,
+      cost: 0,
+      assistant_message_count: 2,
+      is_subagent: false,
+      model: 'gpt-5.3-codex',
+      provider: 'openai',
+      install_id: '33333333-3333-4333-8333-333333333333',
+      schema_version: 1,
+    })
   })
 })

package/src/analytics.ts

@@ -46,6 +46,7 @@ export type AnalyticsEventName =
   | 'session_created'
   | 'turn_started'
   | 'turn_completed'
+  | 'tokens_used'
 
 export type AnalyticsBotMode = 'gateway' | 'self_hosted'
 

package/src/cli-commands/send.ts

@@ -111,6 +111,14 @@ cli
     '--send-at <schedule>',
     'Schedule send for future (UTC ISO date/time ending in Z, or cron expression)',
   )
+  .option(
+    '--pre-run <command>',
+    'Run a shell command in the project before starting a scheduled task',
+  )
+  .option(
+    '--allow-concurrency',
+    'Allow concurrent sessions from the same scheduled task',
+  )
   .option('--thread <threadId>', 'Post prompt to an existing thread')
   .option(
     '--session <sessionId>',
@@ -143,6 +151,11 @@ cli
 
         const existingThreadMode = Boolean(threadId || sessionId)
 
+        if ((options.preRun || options.allowConcurrency) && !sendAt) {
+          cliLogger.error('--pre-run and --allow-concurrency require --send-at')
+          process.exit(EXIT_NO_RESTART)
+        }
+
         if (threadId && sessionId) {
           cliLogger.error('Use either --thread or --session, not both')
           process.exit(EXIT_NO_RESTART)
@@ -495,6 +508,8 @@ cli
               permissions: options.permission?.length ? options.permission : null,
               injectionGuardPatterns: options.injectionGuard?.length ? options.injectionGuard : null,
               parentSessionId: options.parentSession || null,
+              preRunCommand: options.preRun || null,
+              allowConcurrency: Boolean(options.allowConcurrency),
             }
             const taskId = await createScheduledTask({
               scheduleKind: parsedSchedule.scheduleKind,
@@ -542,7 +557,7 @@ cli
 
           if (threadTargetUser) {
             cliLogger.log(
-              `Adding user ${threadTargetUser.username} to thread...`,
+              `Adding user ${threadTargetUser.username || threadTargetUser.id} to thread...`,
             )
             const addMemberResult = await ensureThreadMember({
               rest,
@@ -691,6 +706,8 @@ cli
             permissions: options.permission?.length ? options.permission : null,
             injectionGuardPatterns: options.injectionGuard?.length ? options.injectionGuard : null,
             parentSessionId: options.parentSession || null,
+            preRunCommand: options.preRun || null,
+            allowConcurrency: Boolean(options.allowConcurrency),
           }
           const taskId = await createScheduledTask({
             scheduleKind: parsedSchedule.scheduleKind,
@@ -722,8 +739,8 @@ cli
               ...(worktreeName && { worktree: worktreeName }),
               ...(resolvedCwd && { cwd: resolvedCwd }),
               ...(resolvedUser && {
-                username: resolvedUser.username,
                 userId: resolvedUser.id,
+                ...(resolvedUser.username && { username: resolvedUser.username }),
               }),
               ...(options.agent && { agent: options.agent }),
               ...(options.model && { model: options.model }),
@@ -773,7 +790,9 @@ cli
 
         // Add user to thread if specified
         if (resolvedUser) {
-          cliLogger.log(`Adding user ${resolvedUser.username} to thread...`)
+          cliLogger.log(
+            `Adding user ${resolvedUser.username || resolvedUser.id} to thread...`,
+          )
           await rest.put(Routes.threadMembers(threadData.id, resolvedUser.id))
         }
 

package/src/cli-commands/task.ts

@@ -60,7 +60,7 @@ cli
       }
 
       console.log(
-        'id | status | message | channelId | userId | projectName | folderName | agent | model | timeRemaining | firesAt | cron',
+        'id | status | message | channelId | userId | projectName | folderName | agent | model | preRun | allowConcurrency | timeRemaining | firesAt | cron',
       )
 
       tasks.forEach((task) => {
@@ -71,6 +71,10 @@ cli
         const userId = payload instanceof Error ? '?' : payload.userId || '-'
         const agent = payload instanceof Error ? '?' : payload.agent || '-'
         const model = payload instanceof Error ? '?' : payload.model || '-'
+        const preRun = payload instanceof Error ? '?' : payload.preRunCommand || '-'
+        const allowConcurrency = payload instanceof Error
+          ? '?'
+          : String(payload.allowConcurrency)
         const projectDirectory = task.project_directory || ''
         const projectName = projectDirectory
           ? path.basename(projectDirectory)
@@ -86,7 +90,7 @@ cli
           task.schedule_kind === 'cron' ? task.cron_expr || '-' : '-'
 
         console.log(
-          `${task.id} | ${task.status} | ${task.prompt_preview} | ${task.channel_id || '-'} | ${userId} | ${projectName} | ${folderName} | ${agent} | ${model} | ${formatRelativeTime(task.next_run_at)} | ${firesAt} | ${cronValue}`,
+          `${task.id} | ${task.status} | ${task.prompt_preview} | ${task.channel_id || '-'} | ${userId} | ${projectName} | ${folderName} | ${agent} | ${model} | ${preRun} | ${allowConcurrency} | ${formatRelativeTime(task.next_run_at)} | ${firesAt} | ${cronValue}`,
         )
       })
 
@@ -137,10 +141,10 @@ async function resolveTaskUser({
 }: {
   user: string
   channelId: string | null
-}): Promise<{ id: string; username: string } | Error> {
+}): Promise<{ id: string; username?: string } | Error> {
   const directUserId = getDiscordUserIdFromUserOption(user)
   if (directUserId) {
-    return { id: directUserId, username: directUserId }
+    return { id: directUserId }
   }
 
   if (!channelId) {
@@ -181,36 +185,35 @@ cli
     '--model <model>',
     'Model for the scheduled session, format provider/model (empty string clears)',
   )
+  .option('--pre-run <command>', 'New pre-run command (empty string clears)')
+  .option(
+    '--allow-concurrency <enabled>',
+    z.enum(['true', 'false']).describe('Allow concurrent sessions: true or false'),
+  )
   .option(
     '-u, --user <user>',
     'Discord user ID, mention, or username added to the task thread',
   )
-  .action(
-    async (
-      id: string,
-      options: {
-        prompt?: string
-        sendAt?: string
-        user?: string
-        agent?: string
-        model?: string
-      },
-    ) => {
+  .action(async (id, options) => {
     try {
       const trimmedPrompt =
         options.prompt === undefined ? undefined : options.prompt.trim()
       const hasAgent = options.agent !== undefined
       const hasModel = options.model !== undefined
+      const hasPreRun = options.preRun !== undefined
+      const hasAllowConcurrency = options.allowConcurrency !== undefined
 
       if (
         !trimmedPrompt &&
         !options.sendAt &&
         !options.user &&
         !hasAgent &&
-        !hasModel
+        !hasModel &&
+        !hasPreRun &&
+        !hasAllowConcurrency
       ) {
         cliLogger.error(
-          'Provide at least --prompt, --send-at, --user, --agent or --model',
+          'Provide at least --prompt, --send-at, --user, --agent, --model, --pre-run or --allow-concurrency',
         )
         process.exit(EXIT_NO_RESTART)
       }
@@ -265,10 +268,14 @@ cli
         ...existingPayload,
         prompt: newPrompt,
         ...(resolvedUser
-          ? { userId: resolvedUser.id, username: resolvedUser.username }
+          ? { userId: resolvedUser.id, username: resolvedUser.username || null }
           : {}),
         ...(hasAgent ? { agent: options.agent!.trim() || null } : {}),
         ...(hasModel ? { model: options.model!.trim() || null } : {}),
+        ...(hasPreRun ? { preRunCommand: options.preRun!.trim() || null } : {}),
+        ...(hasAllowConcurrency
+          ? { allowConcurrency: options.allowConcurrency === 'true' }
+          : {}),
       }
 
       const updateData: Parameters<typeof updateScheduledTask>[0] = {
@@ -303,7 +310,9 @@ cli
 
       const parts: string[] = [`Updated task ${taskId}`]
       if (resolvedUser) {
-        parts.push(`user ${resolvedUser.username} will be added to the thread`)
+        parts.push(
+          `user ${resolvedUser.username || resolvedUser.id} will be added to the thread`,
+        )
       }
       if (hasAgent) {
         parts.push(`agent=${updatedPayload.agent || '-'}`)
@@ -311,6 +320,10 @@ cli
       if (hasModel) {
         parts.push(`model=${updatedPayload.model || '-'}`)
       }
+      if (hasPreRun) parts.push(`preRun=${updatedPayload.preRunCommand || '-'}`)
+      if (hasAllowConcurrency) {
+        parts.push(`allowConcurrency=${updatedPayload.allowConcurrency}`)
+      }
       cliLogger.log(parts.join(' | '))
       process.exit(0)
     } catch (error) {

package/src/cli-runner.test.ts

@@ -1,5 +1,20 @@
 import { describe, expect, test } from 'vitest'
-import { getOpenUrlCommand, isTransientNetworkError } from './cli-runner.js'
+import { REST } from 'discord.js'
+import {
+  getOpenUrlCommand,
+  isTransientNetworkError,
+  resolveDiscordUserOption,
+} from './cli-runner.js'
+
+test('raw Discord user ID does not invent a username', async () => {
+  const user = await resolveDiscordUserOption({
+    user: '535922349652836367',
+    guildId: '1422625037164351591',
+    rest: new REST(),
+  })
+
+  expect(user).toEqual({ id: '535922349652836367' })
+})
 
 describe('getOpenUrlCommand', () => {
   const installUrl = 'https://kimaki.dev/discord-install?clientId=abc&clientSecret=def'