kimaki 1.3.0 → 1.5.0

package/dist/lock-routes.d.ts

@@ -16,6 +16,8 @@ export declare const sendInput: z.ZodObject<{
     baseBranch: z.ZodOptional<z.ZodString>;
     worktree: z.ZodOptional<z.ZodString>;
     notifyOnly: z.ZodOptional<z.ZodBoolean>;
+    wait: z.ZodOptional<z.ZodNumber>;
+    senderSessionId: z.ZodOptional<z.ZodString>;
     permissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
     prompt: z.ZodString;
     files: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -46,6 +48,8 @@ export declare const lockRoutes: {
             baseBranch: z.ZodOptional<z.ZodString>;
             worktree: z.ZodOptional<z.ZodString>;
             notifyOnly: z.ZodOptional<z.ZodBoolean>;
+            wait: z.ZodOptional<z.ZodNumber>;
+            senderSessionId: z.ZodOptional<z.ZodString>;
             permissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
             prompt: z.ZodString;
             files: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -71,6 +75,8 @@ export declare const lockRoutes: {
             baseBranch?: string | undefined;
             worktree?: string | undefined;
             notifyOnly?: boolean | undefined;
+            wait?: number | undefined;
+            senderSessionId?: string | undefined;
             permissions?: string[] | undefined;
             files?: {
                 uri: string;
@@ -100,7 +106,10 @@ export declare const lockRoutes: {
                 name: string;
             }[];
         }, signal: AbortSignal) => Promise<Error | {
-            uploaded: string[];
+            uploaded: {
+                name: string;
+                url: string | null;
+            }[];
         }>;
     };
     status: {
@@ -125,12 +134,26 @@ export declare const lockRoutes: {
             }[];
         }>;
     };
+    'session.warmup': {
+        handle: (bot: Bot, raw: unknown, signal: AbortSignal) => Promise<Error | {
+            data: unknown;
+        }>;
+        input: z.ZodObject<{
+            sessionId: z.ZodString;
+        }, z.core.$strip>;
+        run: (bot: Bot, input: {
+            sessionId: string;
+        }, signal: AbortSignal) => Promise<Error | DbError | {
+            busy: boolean;
+            sleeping: boolean;
+        }>;
+    };
     restart: {
         handle: (bot: Bot, raw: unknown, signal: AbortSignal) => Promise<Error | {
             data: unknown;
         }>;
         input: z.ZodObject<{}, z.core.$strip>;
-        run: (bot: Bot, input: Record<string, never>, signal: AbortSignal) => Promise<Error | ConfigError | {
+        run: (bot: Bot, input: Record<string, never>, signal: AbortSignal) => Promise<ConfigError | Error | {
             restarting: boolean;
             pid: number;
         }>;
@@ -144,7 +167,7 @@ export declare const lockRoutes: {
         }, z.core.$strip>;
         run: (bot: Bot, input: {
             durationMs: number;
-        }, signal: AbortSignal) => Promise<Error | ConfigError | FilesystemError | {
+        }, signal: AbortSignal) => Promise<ConfigError | Error | FilesystemError | {
             path: string;
         }>;
     };
@@ -174,7 +197,7 @@ export declare const lockRoutes: {
             reason?: string | undefined;
             sessionId?: string | undefined;
             threadId?: string | undefined;
-        }, signal: AbortSignal) => Promise<Error | DbError | ConfigError | {
+        }, signal: AbortSignal) => Promise<ConfigError | Error | DbError | {
             sessionId: string;
             threadId: string;
             wakeAt: string;
@@ -204,7 +227,7 @@ export declare const lockRoutes: {
             preRun?: string | undefined;
             user?: string | undefined;
             allowConcurrency?: boolean | undefined;
-        }, signal: AbortSignal) => Promise<Error | DbError | ConfigError | {
+        }, signal: AbortSignal) => Promise<ConfigError | Error | DbError | {
             routineId: number;
             updated: string[];
         }>;
@@ -218,7 +241,7 @@ export declare const lockRoutes: {
         }, z.core.$strip>;
         run: (bot: Bot, input: {
             id: number;
-        }, signal: AbortSignal) => Promise<Error | DbError | ConfigError | {
+        }, signal: AbortSignal) => Promise<ConfigError | Error | DbError | {
             routineId: number;
             deleted: boolean;
         }>;
@@ -263,7 +286,7 @@ export declare const lockRoutes: {
             toolCall?: string | undefined;
             sessionId?: string | undefined;
             threadId?: string | undefined;
-        }, signal: AbortSignal) => Promise<Error | ConfigError | {
+        }, signal: AbortSignal) => Promise<ConfigError | Error | {
             shown: true;
         } | {
             paths: string[];
@@ -271,6 +294,19 @@ export declare const lockRoutes: {
             cancelled: true;
         }>;
     };
+    'session.buttons': {
+        handle: (bot: Bot, raw: unknown, signal: AbortSignal) => Promise<Error | {
+            data: unknown;
+        }>;
+        input: z.ZodObject<{
+            sessionIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+        run: (bot: Bot, input: {
+            sessionIds: string[];
+        }, signal: AbortSignal) => Promise<Error | {
+            [k: string]: string[];
+        }>;
+    };
     'upload-request': {
         handle: (bot: Bot, raw: unknown, signal: AbortSignal) => Promise<Error | {
             data: unknown;
@@ -290,7 +326,7 @@ export declare const lockRoutes: {
             toolCall?: string | undefined;
             sessionId?: string | undefined;
             threadId?: string | undefined;
-        }, signal: AbortSignal) => Promise<Error | ConfigError | {
+        }, signal: AbortSignal) => Promise<ConfigError | Error | {
             shown: true;
         } | {
             paths: string[];
@@ -367,15 +403,15 @@ export declare const lockRoutes: {
         input: z.ZodObject<{
             id: z.ZodString;
             operation: z.ZodPipe<z.ZodString, z.ZodEnum<{
-                label: "label";
                 remove: "remove";
                 activate: "activate";
+                label: "label";
             }>>;
             label: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>;
         run: (bot: Bot, input: {
             id: string;
-            operation: "label" | "remove" | "activate";
+            operation: "remove" | "activate" | "label";
             label?: string | undefined;
         }, signal: AbortSignal) => Promise<Error | import("./errors.ts").OpenCodeError | OpenCodeUnavailableError | {
             message: string;
@@ -397,7 +433,7 @@ export declare const lockRoutes: {
             text: "on" | "off";
             channelId?: string | undefined;
             directory?: string | undefined;
-        }, signal: AbortSignal) => Promise<Error | DbError | ConfigError | {
+        }, signal: AbortSignal) => Promise<ConfigError | Error | DbError | {
             enabled: boolean;
         }>;
     };
@@ -416,7 +452,7 @@ export declare const lockRoutes: {
             clear?: boolean | undefined;
             channelId?: string | undefined;
             directory?: string | undefined;
-        }, signal: AbortSignal) => Promise<Error | DbError | ConfigError | {
+        }, signal: AbortSignal) => Promise<ConfigError | Error | DbError | {
             cleared: boolean;
         } | {
             agent: string;
@@ -439,7 +475,7 @@ export declare const lockRoutes: {
             clear?: boolean | undefined;
             channelId?: string | undefined;
             directory?: string | undefined;
-        }, signal: AbortSignal) => Promise<Error | DbError | ConfigError | {
+        }, signal: AbortSignal) => Promise<ConfigError | Error | DbError | {
             cleared: boolean;
         } | {
             model: {
@@ -462,7 +498,7 @@ export declare const lockRoutes: {
             model?: string | undefined;
             variant?: string | undefined;
             clear?: boolean | undefined;
-        }, signal: AbortSignal) => Promise<Error | DbError | ConfigError | {
+        }, signal: AbortSignal) => Promise<ConfigError | Error | DbError | {
             cleared: boolean;
         } | {
             model: {
@@ -478,18 +514,18 @@ export declare const lockRoutes: {
         }>;
         input: z.ZodObject<{
             text: z.ZodPipe<z.ZodString, z.ZodEnum<{
-                text: "text";
                 tools: "tools";
+                text: "text";
             }>>;
             channelId: z.ZodOptional<z.ZodString>;
             directory: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>;
         run: (bot: Bot, input: {
-            text: "text" | "tools";
+            text: "tools" | "text";
             channelId?: string | undefined;
             directory?: string | undefined;
-        }, signal: AbortSignal) => Promise<Error | DbError | ConfigError | {
-            verbosity: "text" | "tools";
+        }, signal: AbortSignal) => Promise<ConfigError | Error | DbError | {
+            verbosity: "tools" | "text";
         }>;
     };
     'worktree.list': {
@@ -503,7 +539,7 @@ export declare const lockRoutes: {
         run: (bot: Bot, input: {
             channelId?: string | undefined;
             directory?: string | undefined;
-        }, signal: AbortSignal) => Promise<Error | DbError | ConfigError | import("./worktrees.ts").GitError | {
+        }, signal: AbortSignal) => Promise<ConfigError | Error | DbError | import("./worktrees.ts").GitError | {
             entries: import("./worktrees.ts").GitWorktree[];
             enabled: boolean;
         }>;
@@ -548,7 +584,7 @@ export declare const lockRoutes: {
             targetBranch?: string | undefined;
             channelId?: string | undefined;
             directory?: string | undefined;
-        }, signal: AbortSignal) => Promise<Error | DbError | import("./errors.ts").OpenCodeError | OpenCodeUnavailableError | ConfigError | import("./worktrees.ts").GitError | {
+        }, signal: AbortSignal) => Promise<ConfigError | Error | DbError | import("./errors.ts").OpenCodeError | OpenCodeUnavailableError | import("./worktrees.ts").GitError | {
             targetBranch: string;
             commitCount: number;
             sha: string;
@@ -576,7 +612,7 @@ export declare const lockRoutes: {
             targetBranch?: string | undefined;
             channelId?: string | undefined;
             directory?: string | undefined;
-        }, signal: AbortSignal) => Promise<Error | DbError | import("./errors.ts").OpenCodeError | OpenCodeUnavailableError | ConfigError | import("./worktrees.ts").GitError | {
+        }, signal: AbortSignal) => Promise<ConfigError | Error | DbError | import("./errors.ts").OpenCodeError | OpenCodeUnavailableError | import("./worktrees.ts").GitError | {
             targetBranch: string;
             commitCount: number;
             sha: string;
@@ -595,7 +631,7 @@ export declare const lockRoutes: {
         run: (bot: Bot, input: {
             sessionId: string;
             channelId?: string | undefined;
-        }, signal: AbortSignal) => Promise<Error | DbError | import("./errors.ts").OpenCodeError | DiscordError | OpenCodeUnavailableError | ConfigError | {
+        }, signal: AbortSignal) => Promise<ConfigError | Error | DbError | import("./errors.ts").OpenCodeError | DiscordError | OpenCodeUnavailableError | {
             title: string;
             threadId: string;
             sessionId: string;
@@ -614,7 +650,7 @@ export declare const lockRoutes: {
             sessionId?: string | undefined;
             threadId?: string | undefined;
             directory?: string | undefined;
-        }, signal: AbortSignal) => Promise<Error | DbError | import("./errors.ts").OpenCodeError | DiscordError | OpenCodeUnavailableError | ConfigError | import("./worktrees.ts").GitError | {
+        }, signal: AbortSignal) => Promise<ConfigError | Error | DbError | import("./errors.ts").OpenCodeError | DiscordError | OpenCodeUnavailableError | import("./worktrees.ts").GitError | {
             directory: string;
             requestedDirectory?: undefined;
         } | {
@@ -635,7 +671,7 @@ export declare const lockRoutes: {
             text: string;
             sessionId?: string | undefined;
             threadId?: string | undefined;
-        }, signal: AbortSignal) => Promise<Error | import("./errors.ts").OpenCodeError | DiscordError | OpenCodeUnavailableError | ConfigError | {
+        }, signal: AbortSignal) => Promise<ConfigError | Error | import("./errors.ts").OpenCodeError | DiscordError | OpenCodeUnavailableError | {
             title: string;
         }>;
     };
@@ -650,7 +686,7 @@ export declare const lockRoutes: {
         run: (bot: Bot, input: {
             sessionId?: string | undefined;
             threadId?: string | undefined;
-        }, signal: AbortSignal) => Promise<Error | DiscordError | OpenCodeUnavailableError | ConfigError | {
+        }, signal: AbortSignal) => Promise<ConfigError | Error | DiscordError | OpenCodeUnavailableError | {
             archived: boolean;
         }>;
     };
@@ -665,10 +701,26 @@ export declare const lockRoutes: {
         run: (bot: Bot, input: {
             sessionId?: string | undefined;
             threadId?: string | undefined;
-        }, signal: AbortSignal) => Promise<Error | import("./errors.ts").OpenCodeError | OpenCodeUnavailableError | ConfigError | {
+        }, signal: AbortSignal) => Promise<ConfigError | Error | import("./errors.ts").OpenCodeError | OpenCodeUnavailableError | {
             cleared: number;
         }>;
     };
+    'session.compact': {
+        handle: (bot: Bot, raw: unknown, signal: AbortSignal) => Promise<Error | {
+            data: unknown;
+        }>;
+        input: z.ZodObject<{
+            sessionId: z.ZodOptional<z.ZodString>;
+            threadId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        run: (bot: Bot, input: {
+            sessionId?: string | undefined;
+            threadId?: string | undefined;
+        }, signal: AbortSignal) => Promise<ConfigError | Error | import("./errors.ts").OpenCodeError | OpenCodeUnavailableError | {
+            sessionId: string;
+            queued: boolean;
+        }>;
+    };
     'session.fork': {
         handle: (bot: Bot, raw: unknown, signal: AbortSignal) => Promise<Error | {
             data: unknown;
@@ -684,7 +736,7 @@ export declare const lockRoutes: {
             threadId?: string | undefined;
             before?: string | undefined;
             name?: string | undefined;
-        }, signal: AbortSignal) => Promise<Error | DbError | import("./errors.ts").OpenCodeError | DiscordError | OpenCodeUnavailableError | ConfigError | import("./worktrees.ts").GitError | {
+        }, signal: AbortSignal) => Promise<ConfigError | Error | DbError | import("./errors.ts").OpenCodeError | DiscordError | OpenCodeUnavailableError | import("./worktrees.ts").GitError | {
             threadId: string;
             sessionId: string;
         }>;
@@ -719,7 +771,7 @@ export declare const lockRoutes: {
             text: string;
             sessionId?: string | undefined;
             threadId?: string | undefined;
-        }, signal: AbortSignal) => Promise<Error | OpenCodeUnavailableError | ConfigError | {
+        }, signal: AbortSignal) => Promise<ConfigError | Error | OpenCodeUnavailableError | {
             started: boolean;
         }>;
     };
@@ -764,7 +816,7 @@ export declare const lockRoutes: {
         run: (bot: Bot, input: {
             sessionId?: string | undefined;
             threadId?: string | undefined;
-        }, signal: AbortSignal) => Promise<Error | import("./errors.ts").OpenCodeError | import("@opencode/client").SessionInboxInfo[] | OpenCodeUnavailableError | ConfigError>;
+        }, signal: AbortSignal) => Promise<ConfigError | Error | import("./errors.ts").OpenCodeError | OpenCodeUnavailableError | import("@opencode/client").SessionInboxInfo[]>;
     };
     'queue.remove': {
         handle: (bot: Bot, raw: unknown, signal: AbortSignal) => Promise<Error | {
@@ -779,7 +831,7 @@ export declare const lockRoutes: {
             inboxId: string;
             sessionId?: string | undefined;
             threadId?: string | undefined;
-        }, signal: AbortSignal) => Promise<Error | import("./errors.ts").OpenCodeError | OpenCodeUnavailableError | ConfigError | {
+        }, signal: AbortSignal) => Promise<ConfigError | Error | import("./errors.ts").OpenCodeError | OpenCodeUnavailableError | {
             removed: boolean;
         }>;
     };
@@ -794,7 +846,7 @@ export declare const lockRoutes: {
         run: (bot: Bot, input: {
             sessionId?: string | undefined;
             threadId?: string | undefined;
-        }, signal: AbortSignal) => Promise<Error | import("./errors.ts").OpenCodeError | OpenCodeUnavailableError | ConfigError | {
+        }, signal: AbortSignal) => Promise<ConfigError | Error | import("./errors.ts").OpenCodeError | OpenCodeUnavailableError | {
             cleared: number;
         }>;
     };

package/dist/lock-routes.js

@@ -11,7 +11,7 @@ import * as errore from 'errore';
 import * as orm from 'drizzle-orm';
 import { z } from 'zod';
 import { parseButton } from "./agent-ui.js";
-import { fetchThread, oc, parseModel, projectOf } from "./bot.js";
+import { fetchConversation, isCoordinatorChannel, oc, parseModel, projectOf } from "./bot.js";
 import { credential, loginCli } from "./commands/login-commands.js";
 import { setChannelAgent, setChannelModel, setGlobalModel, setVerbosity } from "./commands/preference-commands.js";
 import { channelWorktrees, manageWorktree, newWorktree, setAutoWorktrees } from "./commands/worktree-commands.js";
@@ -21,7 +21,8 @@ import { abort, cancelQueuedPrompt, clearQueue, send, shell, upload } from "./pr
 import { createTask, deleteTask, editTask, runTaskNow } from "./scheduler.js";
 import * as schema from "./schema.js";
 import { channelForDirectory, channelForSession, fork, resume, sessionCwd } from "./sessions.js";
-import { createSleep } from "./sleeps.js";
+import { createSleep, sleepsWarm } from "./sleeps.js";
+import { conversationTyping, workersTyping } from "./thread-reducer.js";
 import { worktreeName } from "./worktrees.js";
 // Keeps input and run correlated, and gives the dispatcher one untyped entry point.
 function route(definition) {
@@ -70,6 +71,10 @@ const sendFields = {
     // '' asks for an automatic name.
     worktree: z.string({ error: 'worktree must be a name or an empty string for an automatic name' }).optional(),
     notifyOnly: z.boolean({ error: 'notifyOnly must be boolean' }).optional(),
+    // Seconds the CLI waits for the run (`--wait [seconds]`): a run that ends within them sends no coordinator note.
+    wait: z.number({ error: 'wait must be a number of seconds' }).positive({ error: 'wait must be a positive number of seconds' }).optional(),
+    // OPENCODE_SESSION_ID of the shell that ran `kimaki send`: a coordinator wakes when the runs it prompted end.
+    senderSessionId: text('senderSessionId').optional(),
     permissions: z.array(z.string(), { error: 'Permission rules must be strings' }).optional(),
     prompt: text('prompt'),
     files: z.array(z.object({ uri: z.string(), name: z.string() }), { error: 'files must contain uri and name strings' }).optional(),
@@ -241,6 +246,20 @@ async function snapshotHeap({ dataDir }) {
         return chmod;
     return { path: written };
 }
+// The coordinator or a thread of its channel runs, from the thread views.
+function coordinatorBusy(bot, sessionId) {
+    const { sessionThreads, roots, threads } = bot.store.getState();
+    // A coordinator's conversation is its channel. A replaced one (/reset-coordinator), one of a
+    // channel with coordinator mode off, or a thread session is never busy.
+    const channelId = sessionThreads[sessionId];
+    if (!channelId || roots[channelId] !== sessionId || !isCoordinatorChannel(bot, channelId))
+        return false;
+    const view = threads[channelId];
+    // An idle coordinator has no view after a bot restart; its threads do.
+    if (!view)
+        return workersTyping({ threads, channelId });
+    return view.coordinator && conversationTyping({ threads, threadId: channelId });
+}
 const loginField = z.string({ error: 'Login fields must be non-empty strings' }).min(1, { error: 'Login fields must be non-empty strings' }).optional();
 export const lockRoutes = {
     send: route({
@@ -273,6 +292,17 @@ export const lockRoutes = {
             };
         },
     }),
+    // The plugin keeps a session's prompt cache warm while its coordinator channel is busy
+    // or it sleeps (plugin/coordinator.ts).
+    'session.warmup': route({
+        input: z.object({ sessionId: text('sessionId') }),
+        run: async (bot, { sessionId }) => {
+            const sleeping = await sleepsWarm(bot, sessionId);
+            if (sleeping instanceof Error)
+                return sleeping;
+            return { busy: coordinatorBusy(bot, sessionId), sleeping };
+        },
+    }),
     restart: route({
         input: z.object({}),
         run: async (bot) => {
@@ -350,6 +380,17 @@ export const lockRoutes = {
             return bot.features.agentUi.request({ ...input, sessionId, content: { buttons }, signal });
         },
     }),
+    // Labels of buttons each session showed and the user did not click yet (`kimaki session wait`).
+    'session.buttons': route({
+        input: z.object({ sessionIds: z.array(text('sessionId'), { error: 'sessionIds must be an array' }) }),
+        run: async (bot, { sessionIds }) => {
+            const prompts = Object.values(bot.store.getState().threads).flatMap((view) => view.agentUi);
+            return Object.fromEntries(sessionIds.map((sessionId) => [
+                sessionId,
+                prompts.flatMap((prompt) => prompt.sessionId === sessionId ? (prompt.buttons ?? []).map((item) => item.label) : []),
+            ]));
+        },
+    }),
     'upload-request': route({
         input: z.object({
             ...agentUiFields,
@@ -488,10 +529,10 @@ export const lockRoutes = {
             const target = localSession(bot, input);
             if (target instanceof Error)
                 return target;
-            const thread = await fetchThread(bot, target.threadId);
+            const thread = await fetchConversation(bot, target.threadId);
             if (thread instanceof Error)
                 return thread;
-            return sessionCwd(bot, { thread, directory: input.directory });
+            return sessionCwd(bot, { conversation: thread, directory: input.directory });
         },
     }),
     'session.title': route({
@@ -504,9 +545,12 @@ export const lockRoutes = {
             const renamed = await oc(bot, 'session.update', (client) => client.session.update({ sessionID: target.sessionId, title }));
             if (renamed instanceof Error)
                 return renamed;
-            const thread = await fetchThread(bot, target.threadId);
+            const thread = await fetchConversation(bot, target.threadId);
             if (thread instanceof Error)
                 return thread;
+            // A coordinator channel keeps its project name.
+            if (!thread.isThread())
+                return { title };
             const updated = await thread.setName(title.slice(0, 100)).catch((cause) => new DiscordError({ operation: 'rename thread', cause }));
             if (updated instanceof Error)
                 return updated;
@@ -519,9 +563,11 @@ export const lockRoutes = {
             const target = localSession(bot, input);
             if (target instanceof Error)
                 return target;
-            const thread = await fetchThread(bot, target.threadId);
+            const thread = await fetchConversation(bot, target.threadId);
             if (thread instanceof Error)
                 return thread;
+            if (!thread.isThread())
+                return new ConfigError({ reason: 'A coordinator channel cannot be archived' });
             const archived = await thread.setArchived(true).catch((cause) => new DiscordError({ operation: 'archive thread', cause }));
             if (archived instanceof Error)
                 return archived;
@@ -537,17 +583,31 @@ export const lockRoutes = {
             return abort(bot, { threadId: target.threadId });
         },
     }),
+    'session.compact': route({
+        input: sessionInput({}),
+        run: async (bot, input) => {
+            const target = localSession(bot, input);
+            if (target instanceof Error)
+                return target;
+            // Queued, so an agent compacting its own session finishes its turn first.
+            const sessionID = input.sessionId ?? target.sessionId;
+            const compaction = await oc(bot, 'session.compact', (client) => client.session.compact({ sessionID, delivery: 'queue' }));
+            if (compaction instanceof Error)
+                return compaction;
+            return { sessionId: sessionID, queued: true };
+        },
+    }),
     'session.fork': route({
         input: sessionInput({ before: text('before').optional(), name: text('name').optional() }),
         run: async (bot, input) => {
             const target = localSession(bot, input);
             if (target instanceof Error)
                 return target;
-            const thread = await fetchThread(bot, target.threadId);
+            const thread = await fetchConversation(bot, target.threadId);
             if (thread instanceof Error)
                 return thread;
             // A child session ID forks that child, not the root.
-            return fork(bot, { sourceThread: thread, sessionId: input.sessionId ?? target.sessionId, before: input.before, name: input.name, author: cliAuthor(bot) });
+            return fork(bot, { source: thread, sessionId: input.sessionId ?? target.sessionId, before: input.before, name: input.name, author: cliAuthor(bot) });
         },
     }),
     'session.command': route({