clementine-agent 1.18.203 → 1.18.205

package/dist/agent/run-agent-context.js

@@ -127,6 +127,10 @@ const BEHAVIORAL_POSTURE = `## How you operate
 
 **Orchestrator posture (1.18.197).** You are the orchestrator, not the worker. Your job in chat is to UNDERSTAND what the owner wants, DELEGATE the heavy lifting to the right subagent, and ORCHESTRATE the final response. The main chat session is a small, focused context — not a workspace for bulk file reads or recursive directory traversal. Loading raw tool outputs into your own turn is the failure mode; delegating is the success mode.
 
+**Three-tier model discipline (1.18.204).** The default chat path is the Opus orchestrator tier: read the full request, hold memory/project context, decide the route, dispatch workers, and synthesize results. Do not grind large reads, recursive searches, batch lookups, or long tool sequences in your own turn. Use Sonnet workers for substantive subtask execution (hired agents such as Ross/Sasha/Nora, or \`cron-fixer\`). Use Haiku workers for grunt work: \`researcher\` for per-item fan-out and \`discovery\` for file-system locate. Pick the tier by the nature of the work, not by speed.
+
+**Cron-creation guidance.** When creating scheduled tasks or skills, recommend the model tier in frontmatter: \`haiku\` for lookups, classification, simple checks, and lean digests; \`sonnet\` for typical multi-tool work, composing, and summarizing; \`opus\` only for rare crons that genuinely need complex reasoning across many inputs. Most crons should be Sonnet.
+
 **Tool-selection rubric.** Before running tools yourself, ask which bucket the request falls into:
 
 1. **Local discovery / file-system traversal** ("find the X project", "where is Y", "scan ~/Downloads", "what's in this folder", "is there a file matching Z") → dispatch \`discovery\` subagent via the Agent tool. It has its own 200K context and returns paths + summaries. Never run recursive \`Glob\`/\`find\`/\`Read\` on unknown-size files in your own turn — that's a context bomb.

package/dist/agent/run-agent.js

@@ -579,6 +579,7 @@ export async function runAgent(prompt, opts) {
         source,
         profile: opts.profile?.slug,
         forceSubagent: opts.forceSubagent,
+        model: sdkOptions.model,
         effort,
         maxBudgetUsd: maxBudgetUsd ?? 'uncapped',
         agentCount: Object.keys(agents).length,

package/dist/channels/discord-agent-bot.js

@@ -14,7 +14,7 @@
  */
 import { ActionRowBuilder, ActivityType, ChannelType, Client, EmbedBuilder, Events, GatewayIntentBits, ModalBuilder, Partials, REST, Routes, SlashCommandBuilder, TextInputBuilder, TextInputStyle, } from 'discord.js';
 import pino from 'pino';
-import { chunkText, DiscordStreamingMessage, friendlyToolName, sanitizeResponse, rehydrateStatusEmbed, setSavedStatusEmbed } from './discord-utils.js';
+import { chunkText, DiscordStreamingMessage, sanitizeResponse, rehydrateStatusEmbed, setSavedStatusEmbed } from './discord-utils.js';
 import { MODELS } from '../config.js';
 import * as cronParser from 'cron-parser';
 const logger = pino({ name: 'clementine.agent-bot' });
@@ -813,9 +813,9 @@ export class AgentBotClient {
             }, undefined, // model
             undefined, // maxTurns
             async (toolName, toolInput) => {
-                streamer.setToolStatus(friendlyToolName(toolName, toolInput));
+                streamer.recordToolActivity(toolName, toolInput);
             }, async (status) => {
-                streamer.setToolStatus(status);
+                streamer.setProgressStatus(status);
             });
             await streamer.finalize(response);
         }

package/dist/channels/discord-utils.d.ts

@@ -24,11 +24,22 @@ export declare function sanitizeResponse(text: string): string;
 export declare function chunkText(text: string, maxLen?: number): string[];
 export declare function sendChunked(channel: Message['channel'], text: string): Promise<void>;
 export declare function friendlyToolName(name: string, input?: Record<string, unknown>): string;
+export type DiscordWorkActivityKind = 'read' | 'write' | 'command' | 'delegate' | 'external' | 'memory' | 'other';
+export interface DiscordWorkCardState {
+    startedAt: number;
+    status: string;
+    toolCallCount: number;
+    counts: Record<DiscordWorkActivityKind, number>;
+    recentActivities: string[];
+}
+export declare function classifyDiscordWorkActivity(toolName: string): DiscordWorkActivityKind;
+export declare function buildDiscordWorkCard(state: DiscordWorkCardState, now?: number): string;
 export declare class DiscordStreamingMessage {
     private message;
     private lastEdit;
     private pendingText;
     private lastFlushedText;
+    private lastFlushedDisplay;
     private isFinal;
     private channel;
     private flushTimer;
@@ -37,17 +48,22 @@ export declare class DiscordStreamingMessage {
     private startTime;
     private toolCallCount;
     private lastTextTime;
+    private workCard;
     /** The message ID of the final bot response (available after finalize). */
     messageId: string | null;
     constructor(channel: Message['channel']);
     start(): Promise<void>;
     /** Update the tool activity status line shown during streaming. */
     setToolStatus(status: string): void;
+    /** Update non-tool progress, such as queueing/routing/session-reset stages. */
+    setProgressStatus(status: string): void;
+    /** Record a concrete tool start so the live work card shows real activity. */
+    recordToolActivity(toolName: string, input?: Record<string, unknown>): void;
+    private recordWorkActivity;
+    private requestFlush;
     update(text: string): Promise<void>;
     finalize(text: string): Promise<void>;
     discard(): Promise<void>;
-    /** Format elapsed milliseconds as human-readable duration. */
-    private formatElapsed;
     private flush;
 }
 export type CronEmbedType = 'success' | 'progress' | 'error';

package/dist/channels/discord-utils.js

@@ -166,11 +166,80 @@ export function friendlyToolName(name, input) {
     const short = name.includes('__') ? name.split('__').pop() : name;
     return `\ud83d\udd27 ${short.replace(/_/g, ' ')}`;
 }
+function emptyWorkCounts() {
+    return {
+        read: 0,
+        write: 0,
+        command: 0,
+        delegate: 0,
+        external: 0,
+        memory: 0,
+        other: 0,
+    };
+}
+function formatElapsed(ms) {
+    const s = Math.max(0, Math.floor(ms / 1000));
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    const rem = s % 60;
+    return rem > 0 ? `${m}m ${rem}s` : `${m}m`;
+}
+function cleanCardText(value) {
+    return sanitizeResponse(value.replace(/\s+/g, ' ').trim()).slice(0, 120);
+}
+export function classifyDiscordWorkActivity(toolName) {
+    const name = toolName.toLowerCase();
+    if (name === 'agent' || name.includes('agent') || name.includes('researcher') || name.includes('discovery'))
+        return 'delegate';
+    if (name === 'bash')
+        return 'command';
+    if (name === 'write' || name === 'edit' || name === 'notebookedit')
+        return 'write';
+    if (name.includes('memory_') || name.includes('transcript_') || name.includes('note_'))
+        return 'memory';
+    if (name === 'read' || name === 'glob' || name === 'grep' || name.includes('search') || name.includes('fetch') || name.includes('list') || name.includes('get_') || name.includes('read_'))
+        return 'read';
+    if (/(^|[_\W])(send|create|update|delete|post|apply|move|rename|archive|remove|enable|disable|assign|cancel|approve|reply|forward|publish|push|insert|upsert|set)($|[_\W])/i.test(toolName))
+        return 'external';
+    return 'other';
+}
+function describeCounts(counts) {
+    const parts = [
+        ['reads', counts.read],
+        ['writes', counts.write],
+        ['commands', counts.command],
+        ['delegations', counts.delegate],
+        ['external', counts.external],
+        ['memory', counts.memory],
+    ]
+        .filter(([, count]) => Number(count) > 0)
+        .map(([label, count]) => `${label}: ${count}`);
+    return parts.length > 0 ? parts.join(' | ') : 'no tools yet';
+}
+export function buildDiscordWorkCard(state, now = Date.now()) {
+    const status = cleanCardText(state.status || 'thinking...');
+    const lines = [
+        '**Working**',
+        '',
+        `Status: ${status}`,
+        `Elapsed: ${formatElapsed(now - state.startedAt)} | Steps: ${state.toolCallCount}`,
+        `Tools: ${describeCounts(state.counts)}`,
+    ];
+    const recent = state.recentActivities.map(cleanCardText).filter(Boolean).slice(-5);
+    if (recent.length > 0) {
+        lines.push('', 'Recent activity:');
+        for (const item of recent)
+            lines.push(`- ${item}`);
+    }
+    return lines.join('\n').slice(0, 1900);
+}
 export class DiscordStreamingMessage {
     message = null;
     lastEdit = 0;
     pendingText = '';
     lastFlushedText = '';
+    lastFlushedDisplay = '';
     isFinal = false;
     channel;
     flushTimer = null;
@@ -179,6 +248,13 @@ export class DiscordStreamingMessage {
     startTime = Date.now();
     toolCallCount = 0;
     lastTextTime = 0;
+    workCard = {
+        startedAt: this.startTime,
+        status: 'thinking...',
+        toolCallCount: 0,
+        counts: emptyWorkCounts(),
+        recentActivities: [],
+    };
     /** The message ID of the final bot response (available after finalize). */
     messageId = null;
     constructor(channel) {
@@ -187,20 +263,43 @@ export class DiscordStreamingMessage {
     async start() {
         if (!('send' in this.channel))
             return;
-        this.message = await this.channel.send(THINKING_INDICATOR);
+        this.message = await this.channel.send(buildDiscordWorkCard(this.workCard));
         this.lastEdit = Date.now();
         // Periodic refresh keeps elapsed time display current during long silent stretches
         this.progressTimer = setInterval(() => {
-            if (!this.isFinal && this.toolCallCount > 3)
+            if (!this.isFinal)
                 this.flush().catch(() => { });
         }, 30_000);
     }
     /** Update the tool activity status line shown during streaming. */
     setToolStatus(status) {
-        this.toolStatus = status;
-        this.toolCallCount++;
-        // Trigger a flush so the status is actually displayed during long tool chains
-        // where no text tokens are being emitted
+        this.recordWorkActivity(cleanCardText(status), 'other', true);
+    }
+    /** Update non-tool progress, such as queueing/routing/session-reset stages. */
+    setProgressStatus(status) {
+        this.toolStatus = cleanCardText(status);
+        this.workCard.status = this.toolStatus;
+        this.requestFlush();
+    }
+    /** Record a concrete tool start so the live work card shows real activity. */
+    recordToolActivity(toolName, input) {
+        const label = friendlyToolName(toolName, input);
+        this.recordWorkActivity(label, classifyDiscordWorkActivity(toolName), true);
+    }
+    recordWorkActivity(label, kind, countStep) {
+        const cleaned = cleanCardText(label);
+        this.toolStatus = cleaned;
+        this.workCard.status = cleaned;
+        if (countStep) {
+            this.toolCallCount++;
+            this.workCard.toolCallCount = this.toolCallCount;
+            this.workCard.counts[kind] = (this.workCard.counts[kind] ?? 0) + 1;
+            this.workCard.recentActivities.push(cleaned);
+            this.workCard.recentActivities = this.workCard.recentActivities.slice(-5);
+        }
+        this.requestFlush();
+    }
+    requestFlush() {
         const elapsed = Date.now() - this.lastEdit;
         if (elapsed >= STREAM_EDIT_INTERVAL) {
             this.flush().catch(() => { });
@@ -284,15 +383,6 @@ export class DiscordStreamingMessage {
             await this.message.delete().catch(() => { });
         }
     }
-    /** Format elapsed milliseconds as human-readable duration. */
-    formatElapsed(ms) {
-        const s = Math.floor(ms / 1000);
-        if (s < 60)
-            return `${s}s`;
-        const m = Math.floor(s / 60);
-        const rem = s % 60;
-        return rem > 0 ? `${m}m ${rem}s` : `${m}m`;
-    }
     async flush() {
         if (!this.message || this.isFinal)
             return;
@@ -309,7 +399,7 @@ export class DiscordStreamingMessage {
         let display = this.pendingText;
         let statusLine;
         if (showProgress) {
-            const elapsed = this.formatElapsed(Date.now() - this.startTime);
+            const elapsed = formatElapsed(Date.now() - this.startTime);
             const current = this.toolStatus ? ` \u2014 ${this.toolStatus}` : '';
             statusLine = `\n\n*\ud83d\udd27 Working... (${this.toolCallCount} steps, ${elapsed})${current}*`;
         }
@@ -324,18 +414,14 @@ export class DiscordStreamingMessage {
         }
         else {
             // No text yet — show tool status or progress as the main content
-            if (showProgress) {
-                const elapsed = this.formatElapsed(Date.now() - this.startTime);
-                const current = this.toolStatus ? ` \u2014 ${this.toolStatus}` : '';
-                display = `\u2728 *Working... (${this.toolCallCount} steps, ${elapsed})${current}*`;
-            }
-            else {
-                display = this.toolStatus ? `\u2728 *${this.toolStatus}*` : THINKING_INDICATOR;
-            }
+            display = buildDiscordWorkCard(this.workCard);
         }
+        if (display === this.lastFlushedDisplay)
+            return;
         try {
             await this.message.edit(display);
             this.lastFlushedText = this.pendingText;
+            this.lastFlushedDisplay = display;
             this.lastEdit = Date.now();
         }
         catch {

package/dist/channels/discord.js

@@ -10,7 +10,7 @@ import pino from 'pino';
 import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { chunkText, DiscordStreamingMessage, friendlyToolName, formatCronEmbed, rehydrateStatusEmbed, setSavedStatusEmbed, } from './discord-utils.js';
+import { chunkText, DiscordStreamingMessage, formatCronEmbed, rehydrateStatusEmbed, setSavedStatusEmbed, } from './discord-utils.js';
 import { DISCORD_TOKEN, DISCORD_OWNER_ID, DISCORD_WATCHED_CHANNELS, MODELS, ASSISTANT_NAME, OWNER_NAME, PKG_DIR, VAULT_DIR, BASE_DIR, DEFAULT_MODEL_TIER, } from '../config.js';
 import { isSilentGatewayResponse } from '../gateway/router.js';
 import { findProjectByName, getLinkedProjects } from '../agent/assistant.js';
@@ -1164,7 +1164,7 @@ export async function startDiscord(gateway, heartbeat, cronScheduler, dispatcher
             const streamer = new DiscordStreamingMessage(message.channel);
             await streamer.start();
             try {
-                const response = await gateway.handleMessage(sessionKey, effectiveText, (t) => streamer.update(t), oneOffModel, oneOffMaxTurns, (toolName, toolInput) => { streamer.setToolStatus(friendlyToolName(toolName, toolInput)); return Promise.resolve(); }, (status) => { streamer.setToolStatus(status); return Promise.resolve(); });
+                const response = await gateway.handleMessage(sessionKey, effectiveText, (t) => streamer.update(t), oneOffModel, oneOffMaxTurns, (toolName, toolInput) => { streamer.recordToolActivity(toolName, toolInput); return Promise.resolve(); }, (status) => { streamer.setProgressStatus(status); return Promise.resolve(); });
                 if (isSilentGatewayResponse(response)) {
                     await streamer.discard();
                     updatePresence(sessionKey);

package/dist/gateway/router.js

@@ -2190,9 +2190,10 @@ export class Gateway {
                         // 'yes' — respond this time but don't persist
                     }
                 }
-                // Use per-message override, then session default, then global default
+                // Use per-message override, then session default, then Opus as the
+                // chat-orchestrator default. Builder sessions still force Haiku below.
                 const sess = this.sessions.get(sessionKey);
-                const effectiveModel = model ?? sess?.model;
+                const effectiveModel = model ?? sess?.model ?? MODELS.opus;
                 const pendingOverflow = sess?.pendingOverflowResume;
                 if (pendingOverflow) {
                     const ageMs = Date.now() - pendingOverflow.summarizedAt;
@@ -3379,9 +3380,8 @@ export class Gateway {
     }
     getPresenceInfo(sessionKey) {
         const sess = this.sessions.get(sessionKey);
-        const modelName = sess?.model
-            ? Object.entries(MODELS).find(([, v]) => v === sess.model)?.[0] ?? 'sonnet'
-            : 'sonnet';
+        const modelId = sess?.model ?? MODELS.opus;
+        const modelName = Object.entries(MODELS).find(([, v]) => v === modelId)?.[0] ?? modelId;
         const project = sess?.project;
         return {
             model: modelName.charAt(0).toUpperCase() + modelName.slice(1),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clementine-agent",
-  "version": "1.18.203",
+  "version": "1.18.205",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",