clementine-agent 1.18.203 → 1.18.206

package/dist/agent/agent-definitions.js

@@ -61,7 +61,7 @@ const RESEARCHER_PROMPT = [
     '',
     '## Output discipline',
     '',
-    'Return a ONE-PARAGRAPH summary in the format the parent specified. Never raw tool output, never full lists, never unbounded data dumps. If a tool returns 50KB of JSON, extract only the requested fields and discard the rest — your job is to compress.',
+    'Return a ONE-PARAGRAPH summary in the format the parent specified. Hard limit: 250 words unless the parent explicitly asks for a longer artifact. Never raw tool output, never full lists, never unbounded data dumps. If a tool returns 50KB of JSON, extract only the requested fields and discard the rest — your job is to compress.',
     '',
     'If you cannot find the requested data, say so in one line. Do not speculate.',
 ].join('\n');
@@ -106,6 +106,8 @@ const DISCOVERY_PROMPT = [
     'Recommendation: <which path the orchestrator should fetch next, if any>',
     '```',
     '',
+    'Hard output limit: 250 words. Return decision-grade handoff only: paths, counts, sizes, and the next file/action the orchestrator should inspect. Do NOT return a full project report, long markdown excerpts, repeated file inventories, or narrative analysis. If the parent needs detail, point it at the exact file path to read next.',
+    '',
     'If nothing matches, say so in one line.',
     '',
     'You are bounded by max 15 turns. Use them wisely — list, scope, summarize, return.',

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/agent/run-summary.d.ts

@@ -31,6 +31,9 @@ export interface RunSummary {
     failedSideEffects: SideEffectCall[];
     pendingSideEffects: SideEffectCall[];
     unknownEffectCalls: SideEffectCall[];
+    successfulDelegations: SideEffectCall[];
+    failedDelegations: SideEffectCall[];
+    pendingDelegations: SideEffectCall[];
     readOnlyCount: number;
     errors: Array<{
         runId: string;

package/dist/agent/run-summary.js

@@ -66,11 +66,23 @@ export function summarizeRunSideEffects(runIds, eventLog = new EventLog()) {
     const failedSideEffects = [];
     const pendingSideEffects = [];
     const unknownEffectCalls = [];
+    const successfulDelegations = [];
+    const failedDelegations = [];
+    const pendingDelegations = [];
     let readOnlyCount = 0;
     for (const call of events.filter(isToolCall)) {
         const verdict = classifyToolCall(call.toolName, asInput(call.toolInput));
         const result = resultForToolUse(events, call.toolUseId);
         const item = makeCall(call, result, verdict);
+        if (call.toolName === 'Agent') {
+            if (!result)
+                pendingDelegations.push(item);
+            else if (item.result?.successful)
+                successfulDelegations.push(item);
+            else
+                failedDelegations.push(item);
+            continue;
+        }
         if (verdict.kind === 'read_only') {
             readOnlyCount += 1;
             continue;
@@ -110,6 +122,9 @@ export function summarizeRunSideEffects(runIds, eventLog = new EventLog()) {
         failedSideEffects,
         pendingSideEffects,
         unknownEffectCalls,
+        successfulDelegations,
+        failedDelegations,
+        pendingDelegations,
         readOnlyCount,
         errors,
         ...(lastAssistantText ? { lastAssistantText } : {}),
@@ -120,7 +135,10 @@ export function hasOperationalActivity(summary) {
     return summary.successfulSideEffects.length > 0
         || summary.failedSideEffects.length > 0
         || summary.pendingSideEffects.length > 0
-        || summary.unknownEffectCalls.length > 0;
+        || summary.unknownEffectCalls.length > 0
+        || summary.successfulDelegations.length > 0
+        || summary.failedDelegations.length > 0
+        || summary.pendingDelegations.length > 0;
 }
 function toolKindLabel(toolName) {
     const lower = toolName.toLowerCase();
@@ -206,6 +224,41 @@ function recipientPreview(calls, max = 3) {
 function formatGroupedLines(prefix, calls) {
     return groupCounts(calls).map((group) => `- ${group.count} ${group.label} ${prefix}${recipientPreview(group.calls)}`);
 }
+function collectResultText(value) {
+    if (typeof value === 'string')
+        return value;
+    if (Array.isArray(value))
+        return value.map(collectResultText).filter(Boolean).join('\n');
+    if (!value || typeof value !== 'object')
+        return '';
+    const obj = value;
+    return ['text', 'content', 'result', 'message']
+        .map((key) => collectResultText(obj[key]))
+        .filter(Boolean)
+        .join('\n');
+}
+function extractAgentArchivePath(text) {
+    return text.match(/Full payload archived at `([^`]+)`/)?.[1]
+        ?? text.match(/Full output:\s*([^\n]+)/)?.[1]?.trim();
+}
+function extractAgentId(text) {
+    return text.match(/\bagentId:\s*([a-zA-Z0-9_-]+)/)?.[1];
+}
+function formatDelegationCall(call, status) {
+    const description = firstString(call.input.description, call.input.task, call.input.prompt)?.slice(0, 120);
+    const subagentType = firstString(call.input.subagent_type, call.input.subagentType);
+    const resultText = call.result ? collectResultText(call.result.raw) : '';
+    const agentId = extractAgentId(resultText);
+    const archivePath = extractAgentArchivePath(resultText);
+    const pieces = [
+        subagentType ? `${subagentType} subagent` : 'subagent',
+        status,
+        description ? `for "${description}"` : undefined,
+        agentId ? `agentId ${agentId}` : undefined,
+        archivePath ? `archive ${archivePath}` : undefined,
+    ].filter(Boolean);
+    return `- ${pieces.join(' · ')}`;
+}
 export function formatOverflowRecoveryMessage(summary) {
     const lines = [
         'That run hit the context limit after some work had already happened.',
@@ -216,12 +269,28 @@ export function formatOverflowRecoveryMessage(summary) {
         lines.push(...formatGroupedLines('completed', summary.successfulSideEffects));
         lines.push('');
     }
-    if (summary.failedSideEffects.length > 0 || summary.pendingSideEffects.length > 0 || summary.unknownEffectCalls.length > 0) {
+    if (summary.successfulDelegations.length > 0) {
+        lines.push('Delegated work completed before overflow:');
+        for (const call of summary.successfulDelegations.slice(0, 5))
+            lines.push(formatDelegationCall(call, 'completed'));
+        if (summary.successfulDelegations.length > 5)
+            lines.push(`- ...and ${summary.successfulDelegations.length - 5} more completed subagent calls`);
+        lines.push('');
+    }
+    if (summary.failedSideEffects.length > 0
+        || summary.pendingSideEffects.length > 0
+        || summary.unknownEffectCalls.length > 0
+        || summary.failedDelegations.length > 0
+        || summary.pendingDelegations.length > 0) {
         lines.push('Needs attention:');
         if (summary.failedSideEffects.length > 0)
             lines.push(...formatGroupedLines('failed', summary.failedSideEffects));
         if (summary.pendingSideEffects.length > 0)
             lines.push(...formatGroupedLines('started, no confirmation', summary.pendingSideEffects));
+        for (const call of summary.failedDelegations.slice(0, 5))
+            lines.push(formatDelegationCall(call, 'failed'));
+        for (const call of summary.pendingDelegations.slice(0, 5))
+            lines.push(formatDelegationCall(call, 'started, no confirmation'));
         if (summary.unknownEffectCalls.length > 0)
             lines.push(`- ${summary.unknownEffectCalls.length} tool call(s) had unknown external effect`);
         lines.push('');
@@ -261,6 +330,12 @@ export function buildContinuationPrompt(summary, originalRequest) {
             lines.push(`- ...and ${summary.successfulSideEffects.length - 80} more completed side effects in the event log.`);
         lines.push('');
     }
+    if (summary.successfulDelegations.length > 0) {
+        lines.push('Completed delegated work. Do not repeat discovery/research already done unless the archive is insufficient:');
+        for (const call of summary.successfulDelegations.slice(0, 20))
+            lines.push(formatDelegationCall(call, 'completed'));
+        lines.push('');
+    }
     if (summary.failedSideEffects.length > 0) {
         lines.push('Failed side effects that may need retry or reconciliation:');
         for (const call of summary.failedSideEffects.slice(0, 30))

package/dist/agent/tool-output-guard.d.ts

@@ -80,6 +80,8 @@ export interface GuardRunStats {
 export declare function estimateBytes(value: unknown): number;
 interface CompressionContext {
     toolName: string;
+    toolUseId?: string;
+    toolInput?: unknown;
     archivePath: string | null;
     cap: number;
 }

package/dist/agent/tool-output-guard.js

@@ -117,6 +117,101 @@ function tryListShrink(value, ctx) {
     }
     return null;
 }
+function collectTextFragments(value) {
+    if (typeof value === 'string')
+        return [value];
+    if (Array.isArray(value))
+        return value.flatMap((item) => collectTextFragments(item));
+    if (!value || typeof value !== 'object')
+        return [];
+    const obj = value;
+    const out = [];
+    for (const key of ['text', 'content', 'result', 'message']) {
+        const v = obj[key];
+        if (typeof v === 'string')
+            out.push(v);
+        else if (Array.isArray(v) || (v && typeof v === 'object'))
+            out.push(...collectTextFragments(v));
+    }
+    return out;
+}
+function objectField(value, key) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? typeof value[key] === 'string'
+            ? String(value[key]).trim()
+            : undefined
+        : undefined;
+}
+function extractAgentId(text) {
+    return text.match(/\bagentId:\s*([a-zA-Z0-9_-]+)/)?.[1];
+}
+function extractUsageLine(text) {
+    const match = text.match(/<usage>[\s\S]*?(?:<\/usage>|$)/);
+    return match?.[0]?.replace(/\s+/g, ' ').trim().slice(0, 220);
+}
+function stripAgentBoilerplate(text) {
+    return text
+        .replace(/agentId:\s*[a-zA-Z0-9_-]+[\s\S]*$/i, '')
+        .replace(/<usage>[\s\S]*$/i, '')
+        .replace(/^\s*(perfect|great|okay|ok)[.!]?\s+now\s+i\s+have[^\n]*\n+/i, '')
+        .trim();
+}
+function compactMarkdownLines(text) {
+    const lines = stripAgentBoilerplate(text)
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line && line !== '---' && line !== '```');
+    const keep = [];
+    for (const line of lines) {
+        if (keep.length >= 26)
+            break;
+        if (/^#{1,4}\s/.test(line) || /^[-*]\s/.test(line) || /^\d+\.\s/.test(line) || /^[A-Z][^:]{2,60}:/.test(line)) {
+            keep.push(line);
+            continue;
+        }
+        if (keep.length < 8 && line.length <= 220)
+            keep.push(line);
+    }
+    return keep.join('\n');
+}
+function fitUnderBytes(text, maxBytes) {
+    if (estimateBytes(text) <= maxBytes)
+        return text;
+    const marker = '\n\n[...compact handoff truncated; read the archived Agent result for full detail.]';
+    let head = text.slice(0, Math.max(200, maxBytes - estimateBytes(marker) - 200));
+    while (head.length > 200 && estimateBytes(head + marker) > maxBytes) {
+        head = head.slice(0, Math.floor(head.length * 0.9));
+    }
+    return `${head.trimEnd()}${marker}`;
+}
+function tryAgentShrink(value, ctx) {
+    if (ctx.toolName !== 'Agent')
+        return null;
+    const fragments = collectTextFragments(value);
+    const text = fragments.join('\n\n').trim();
+    if (!text)
+        return null;
+    const subagentType = objectField(ctx.toolInput, 'subagent_type');
+    const description = objectField(ctx.toolInput, 'description');
+    const agentId = extractAgentId(text);
+    const usage = extractUsageLine(text);
+    const summary = compactMarkdownLines(text);
+    const archive = archiveHint(ctx, 'full Agent result');
+    const lines = [
+        '[Clementine compacted this Agent result to protect the parent chat context.]',
+        subagentType ? `Subagent: ${subagentType}` : undefined,
+        description ? `Task: ${description}` : undefined,
+        agentId ? `agentId: ${agentId}` : undefined,
+        usage,
+        archive,
+        '',
+        'Decision-grade handoff:',
+        summary || fitUnderBytes(stripAgentBoilerplate(text), Math.max(1_000, Math.floor(ctx.cap * 0.6))),
+        '',
+        'Use this handoff to continue. Read the archived result only if the missing detail is necessary.',
+    ].filter((line) => typeof line === 'string' && line.length > 0);
+    return fitUnderBytes(lines.join('\n'), ctx.cap);
+}
 function shrinkArray(arr, ctx) {
     if (arr.length <= 6) {
         // Don't trim short lists; the bloat is somewhere else (likely a fat body).
@@ -244,6 +339,19 @@ export function compressToolOutput(_toolName, rawOutput, ctx) {
     if (originalBytes <= ctx.cap) {
         return { output: rawOutput, bytesShed: 0, ceilingHit: false, passthrough: true };
     }
+    // Agent tool results are subagent handoffs to the parent orchestrator.
+    // Preserve the decision-grade summary and archive the full result instead
+    // of letting a verbose report refill the parent context after compaction.
+    const agentShrunk = tryAgentShrink(rawOutput, ctx);
+    if (agentShrunk !== null) {
+        const bytes = estimateBytes(agentShrunk);
+        return {
+            output: agentShrunk,
+            bytesShed: Math.max(0, originalBytes - bytes),
+            ceilingHit: originalBytes > ctx.cap * 2,
+            passthrough: false,
+        };
+    }
     // Pass 1: list-shape shrink (preserves structure).
     const shrunk1 = tryListShrink(rawOutput, ctx);
     if (shrunk1 !== null) {
@@ -294,7 +402,7 @@ export function buildGuardHooks(opts) {
         const toolUseId = String(toolUseID ?? evt.tool_use_id ?? 'unknown');
         const rawOutput = evt.tool_response;
         stats.inspected += 1;
-        const usageRatio = opts.usageRatio ? safeRatio(opts.usageRatio) : 0;
+        const usageRatio = Math.max(opts.usageRatio ? safeRatio(opts.usageRatio) : 0, stats.compactions > 0 ? 0.75 : 0);
         const { softCap } = resolveCap(toolName, config, usageRatio);
         const originalBytes = estimateBytes(rawOutput);
         if (originalBytes <= softCap) {
@@ -307,6 +415,7 @@ export function buildGuardHooks(opts) {
         const archivePath = archivePayload(opts.archiveBaseDir ?? BASE_DIR, opts.runId, toolUseId, toolName, rawOutput);
         const outcome = compressToolOutput(toolName, rawOutput, {
             toolName,
+            toolInput: evt.tool_input,
             toolUseId,
             archivePath,
             cap: softCap,

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/config.js

@@ -552,7 +552,10 @@ export const TOOL_OUTPUT_GUARD = {
     softLimitBytes: getEnvOrJsonNumber('TOOL_OUTPUT_GUARD_SOFT_BYTES', json.toolOutputGuard?.softLimitBytes, 30_000),
     hardLimitBytes: getEnvOrJsonNumber('TOOL_OUTPUT_GUARD_HARD_BYTES', json.toolOutputGuard?.hardLimitBytes, 200_000),
     adaptive: boolEnv('TOOL_OUTPUT_GUARD_ADAPTIVE', json.toolOutputGuard?.adaptive, true),
-    perTool: { ...(json.toolOutputGuard?.perTool ?? {}) },
+    // Agent results are especially dangerous: even a "medium" subagent report
+    // refills the parent orchestrator after compaction. Keep the handoff tight;
+    // the full result is archived by tool-output-guard.
+    perTool: { Agent: 4_000, ...(json.toolOutputGuard?.perTool ?? {}) },
 };
 export const DEFAULT_MODEL_TIER = (getEnvOrJson('DEFAULT_MODEL_TIER', json.models?.default, 'sonnet'));
 export const MODEL = MODELS[DEFAULT_MODEL_TIER] ?? MODELS.sonnet;

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.206",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",