clementine-agent 1.18.54 → 1.18.56

package/dist/cli/dashboard.js

@@ -18,6 +18,7 @@ import cron from 'node-cron';
 import { TunnelManager } from './tunnel.js';
 import { AgentManager } from '../agent/agent-manager.js';
 import { discoverMcpServers, getClaudeIntegrations } from '../agent/mcp-bridge.js';
+import { buildBuilderEnrichedMessage, builderSessionKey } from '../dashboard/builder/prompt.js';
 import { AGENTS_DIR, SESSIONS_FILE, applyOneMillionContextRecovery, looksLikeClaudeOneMillionContextError, normalizeClaudeSdkOptionsForOneMillionContext, } from '../config.js';
 import { parseTasks } from '../tools/shared.js';
 import { todayISO } from '../gateway/cron-scheduler.js';
@@ -8019,100 +8020,29 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
         }
     });
     // ── Builder chat endpoint ──────────────────────────────────────────
-    // Track which builder sessions have received the full system prefix
-    const builderSessionInited = new Set();
     app.post('/api/builder/chat', async (req, res) => {
         const { message, artifactType, agentSlug, currentArtifact, attachments, linkedTools } = req.body;
         if (!message || typeof message !== 'string') {
             res.status(400).json({ error: 'message is required' });
             return;
         }
-        const type = artifactType || 'skill';
-        const sessionKey = `dashboard:builder:${type}:${agentSlug || 'clementine'}`;
-        const isFirstMessage = !builderSessionInited.has(sessionKey);
-        // ── Artifact state (compact JSON — no pretty-print to save tokens) ──
-        const artifactContext = currentArtifact
-            ? `\n[CURRENT ARTIFACT STATE]\n\`\`\`json-artifact\n${JSON.stringify(currentArtifact)}\n\`\`\`\n`
-            : '';
-        // ── File attachments — decode base64 text files and inject contents ──
-        let fileContext = '';
-        if (Array.isArray(attachments) && attachments.length > 0) {
-            const fileParts = [];
-            for (const att of attachments) {
-                if (att.filename && att.content) {
-                    try {
-                        const decoded = Buffer.from(att.content, 'base64').toString('utf-8');
-                        // Cap each file at 4K chars to keep context reasonable
-                        const trimmed = decoded.length > 4000 ? decoded.slice(0, 4000) + '\n... (truncated)' : decoded;
-                        fileParts.push(`### ${att.filename}\n\`\`\`\n${trimmed}\n\`\`\``);
-                    }
-                    catch { /* skip binary files */ }
-                }
-            }
-            if (fileParts.length > 0) {
-                fileContext = `\n[REFERENCE FILES — the user attached these for context]\n${fileParts.join('\n\n')}\n`;
-            }
-        }
-        // ── Linked tools context ──
-        let toolContext = '';
-        if (Array.isArray(linkedTools) && linkedTools.length > 0) {
-            toolContext = `\n[LINKED TOOLS — this skill should use these tools: ${linkedTools.join(', ')}]\n`;
-        }
-        // ── Build the enriched message ──
-        let enrichedMessage;
-        if (isFirstMessage) {
-            // Full system prefix on first message only
-            const agentContext = agentSlug ? `You are building this for the agent "${agentSlug}". The skill/cron will be scoped to this agent specifically.\n` : '';
-            const builderPrefix = type === 'skill'
-                ? `[BUILDER MODE: You are helping build a reusable skill. ${agentContext}As you develop the procedure, output the current state as a JSON block:\n` +
-                    '```json-artifact\n{"type":"skill","title":"...","description":"...","triggers":["..."],"steps":"markdown procedure","toolsUsed":["tool1","tool2"]}\n```\n' +
-                    `Update this block in EVERY response as the skill evolves. If the user has linked tools, include them in the toolsUsed array. Ask clarifying questions to refine the procedure. Keep it conversational — one question at a time. ` +
-                    `When the user says "save" or approves, output the final artifact block.]\n\n`
-                : type === 'cron'
-                    ? `[BUILDER MODE: You are helping build a scheduled cron job. As you develop the job, output the current state as a JSON block:\n` +
-                        '```json-artifact\n{"type":"cron","name":"...","schedule":"cron expression","tier":1,"prompt":"the full job prompt","mode":"standard","enabled":true}\n```\n' +
-                        `Update this block in EVERY response as the job evolves. Ask about schedule, what it should do, which tools/APIs it needs, what tier (1=read-only, 2=read-write), and whether it should run in unleashed mode.\n` +
-                        `IMPORTANT: Cron jobs automatically pull in matching skills (learned procedures) at runtime. If the user describes a workflow that should be reusable, suggest creating it as a skill first, then building the cron job that references those trigger keywords. This way the cron gets smarter over time as skills improve.\n` +
-                        `When the user says "save" or approves, output the final artifact block.]\n\n`
-                    : type === 'agent'
-                        ? `[BUILDER MODE: You are helping create a new AI agent team member. As you develop the agent config, output the current state as a JSON block:\n` +
-                            '```json-artifact\n{"type":"agent","name":"...","description":"role description","model":"sonnet","personality":"system prompt / onboarding brief","tools":["tool1","tool2"],"channel":"","tier":2}\n```\n' +
-                            `Update this block in EVERY response as the agent evolves. Ask about: the agent's role, what tools it needs, what model to use (haiku/sonnet/opus), its personality/system prompt, which channel it should operate in, and its security tier.\n` +
-                            `Help the user think about what makes a good agent: clear role, specific tools, focused personality. Keep it conversational — one question at a time.\n` +
-                            `When the user says "save" or approves, output the final artifact block.]\n\n`
-                        : type === 'workflow'
-                            ? `[BUILDER MODE: You are helping the user DRAFT a "trick" — a (possibly multi-step) thing Clementine can do on a schedule or on demand. You are NOT executing the trick. You are not running anything in the background. You are only authoring a spec the user will save, then run later from the dashboard.\n` +
-                                `\n` +
-                                `Hard rules:\n` +
-                                `  - NEVER say "on it", "running in the background", "I'll follow up", "working on it now", or anything else that implies you're executing the user's request. You are drafting a spec.\n` +
-                                `  - Stay strictly conversational. One short question per turn. Update the artifact block on every turn.\n` +
-                                `  - If the user describes "real work" (multi-step actions, scrapers, enrichments, reports), still just draft it — don't dispatch.\n` +
-                                `\n` +
-                                `As you develop the trick, output the current state as a JSON block:\n` +
-                                '```json-artifact\n{"type":"workflow","name":"...","description":"...","schedule":"","model":"","steps":"step1:\\n  prompt: ...\\nstep2:\\n  prompt: ...\\n  dependsOn: step1"}\n```\n' +
-                                `Ask about (in roughly this order, one at a time):\n` +
-                                `  1. The goal (one sentence is fine — confirm it back).\n` +
-                                `  2. When it should run — natural language is fine ("every weekday at 9"); convert to a cron expression in the schedule field. Empty schedule = manual.\n` +
-                                `  3. Which tools, projects, or channels she'll need (MCP servers, local CLIs like sf/gh/gcloud, Slack/Discord targets).\n` +
-                                `  4. Which model — claude-opus-4-7 (most capable), claude-sonnet-4-6 (balanced), or claude-haiku-4-5-20251001 (fastest). Leave model empty if the user doesn't care.\n` +
-                                `Most tricks need only one prompt step. Add steps only when the user explicitly wants a multi-step pipeline.\n` +
-                                `When the user says "save" or approves, output the final artifact block — don't try to save it yourself, the dashboard handles persistence.]\n\n`
-                            : `[BUILDER MODE: You are helping configure an artifact. Output structured JSON blocks as you build.]\n\n`;
-            enrichedMessage = builderPrefix + fileContext + toolContext + artifactContext + message;
-            builderSessionInited.add(sessionKey);
-        }
-        else {
-            // Subsequent messages: just artifact state + files + tools + user message (no repeated prefix)
-            enrichedMessage = fileContext + toolContext + artifactContext + message;
-        }
+        const sessionKey = builderSessionKey(artifactType, agentSlug);
         try {
             const gateway = await getGateway();
-            // Builder generates JSON artifacts — no tool calls. Pin the session
-            // toolset to 'none' so buildOptions strips all MCP servers and tool
-            // schemas from the system prompt. Without this, every tiny builder
-            // turn writes 60–280 KB of cache_creation for tool schemas the
-            // model never uses.
-            gateway.setSessionToolset(sessionKey, 'none');
+            // First-message detection uses the SDK session ID — set after the
+            // first runAgent turn returns, persisted across daemon restarts.
+            // Anchoring on this means we send the system prefix exactly once
+            // per genuine new conversation, not once per process lifetime.
+            const isFirstMessage = !gateway.assistant.getSdkSessionId(sessionKey);
+            const enrichedMessage = buildBuilderEnrichedMessage({
+                message,
+                artifactType,
+                agentSlug,
+                currentArtifact,
+                attachments,
+                linkedTools,
+                isFirstMessage,
+            });
             const response = await gateway.handleMessage(sessionKey, enrichedMessage);
             // Parse any json-artifact blocks from the response
             let artifact = null;
@@ -8165,84 +8095,20 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
         // before the gateway warms up (otherwise some HTTP intermediaries hold
         // the response until first body byte).
         writeEvent('progress', { status: 'connecting…' });
-        // ── Same enrichment as /api/builder/chat (system prefix on first turn,
-        //    artifact + files + tools on every turn). Inlined to keep the diff
-        //    contained; refactor into a helper if a third endpoint shows up.
-        const type = artifactType || 'skill';
-        const sessionKey = `dashboard:builder:${type}:${agentSlug || 'clementine'}`;
-        const isFirstMessage = !builderSessionInited.has(sessionKey);
-        const artifactContext = currentArtifact
-            ? `\n[CURRENT ARTIFACT STATE]\n\`\`\`json-artifact\n${JSON.stringify(currentArtifact)}\n\`\`\`\n`
-            : '';
-        let fileContext = '';
-        if (Array.isArray(attachments) && attachments.length > 0) {
-            const fileParts = [];
-            for (const att of attachments) {
-                if (att.filename && att.content) {
-                    try {
-                        const decoded = Buffer.from(att.content, 'base64').toString('utf-8');
-                        const trimmed = decoded.length > 4000 ? decoded.slice(0, 4000) + '\n... (truncated)' : decoded;
-                        fileParts.push(`### ${att.filename}\n\`\`\`\n${trimmed}\n\`\`\``);
-                    }
-                    catch { /* skip binary files */ }
-                }
-            }
-            if (fileParts.length > 0) {
-                fileContext = `\n[REFERENCE FILES — the user attached these for context]\n${fileParts.join('\n\n')}\n`;
-            }
-        }
-        let toolContext = '';
-        if (Array.isArray(linkedTools) && linkedTools.length > 0) {
-            toolContext = `\n[LINKED TOOLS — this skill should use these tools: ${linkedTools.join(', ')}]\n`;
-        }
-        let enrichedMessage;
-        if (isFirstMessage) {
-            const agentContext = agentSlug ? `You are building this for the agent "${agentSlug}". The skill/cron will be scoped to this agent specifically.\n` : '';
-            const builderPrefix = type === 'skill'
-                ? `[BUILDER MODE: You are helping build a reusable skill. ${agentContext}As you develop the procedure, output the current state as a JSON block:\n` +
-                    '```json-artifact\n{"type":"skill","title":"...","description":"...","triggers":["..."],"steps":"markdown procedure","toolsUsed":["tool1","tool2"]}\n```\n' +
-                    `Update this block in EVERY response as the skill evolves. If the user has linked tools, include them in the toolsUsed array. Ask clarifying questions to refine the procedure. Keep it conversational — one question at a time. ` +
-                    `When the user says "save" or approves, output the final artifact block.]\n\n`
-                : type === 'cron'
-                    ? `[BUILDER MODE: You are helping build a scheduled cron job. As you develop the job, output the current state as a JSON block:\n` +
-                        '```json-artifact\n{"type":"cron","name":"...","schedule":"cron expression","tier":1,"prompt":"the full job prompt","mode":"standard","enabled":true}\n```\n' +
-                        `Update this block in EVERY response as the job evolves. Ask about schedule, what it should do, which tools/APIs it needs, what tier (1=read-only, 2=read-write), and whether it should run in unleashed mode.\n` +
-                        `When the user says "save" or approves, output the final artifact block.]\n\n`
-                    : type === 'agent'
-                        ? `[BUILDER MODE: You are helping create a new AI agent team member. As you develop the agent config, output the current state as a JSON block:\n` +
-                            '```json-artifact\n{"type":"agent","name":"...","description":"role description","model":"sonnet","personality":"system prompt / onboarding brief","tools":["tool1","tool2"],"channel":"","tier":2}\n```\n' +
-                            `Update this block in EVERY response as the agent evolves. Ask about: the agent's role, what tools it needs, what model to use, its personality/system prompt, which channel it should operate in, and its security tier.\n` +
-                            `Keep it conversational — one question at a time. When the user says "save" or approves, output the final artifact block.]\n\n`
-                        : type === 'workflow'
-                            ? `[BUILDER MODE: You are helping the user DRAFT a "trick" — a (possibly multi-step) thing Clementine can do on a schedule or on demand. You are NOT executing the trick. You are not running anything in the background. You are only authoring a spec the user will save, then run later from the dashboard.\n` +
-                                `\n` +
-                                `Hard rules:\n` +
-                                `  - NEVER say "on it", "running in the background", "I'll follow up", "working on it now", or anything else that implies you're executing the user's request. You are drafting a spec.\n` +
-                                `  - Stay strictly conversational. One short question per turn. Update the artifact block on every turn.\n` +
-                                `  - If the user describes "real work" (multi-step actions, scrapers, enrichments, reports), still just draft it — don't dispatch.\n` +
-                                `\n` +
-                                `As you develop the trick, output the current state as a JSON block:\n` +
-                                '```json-artifact\n{"type":"workflow","name":"...","description":"...","schedule":"","model":"","steps":"step1:\\n  prompt: ...\\nstep2:\\n  prompt: ...\\n  dependsOn: step1"}\n```\n' +
-                                `Ask about (in roughly this order, one at a time):\n` +
-                                `  1. The goal (one sentence is fine — confirm it back).\n` +
-                                `  2. When it should run — natural language is fine ("every weekday at 9"); convert to a cron expression in the schedule field. Empty schedule = manual.\n` +
-                                `  3. Which tools, projects, or channels she'll need (MCP servers, local CLIs like sf/gh/gcloud, Slack/Discord targets).\n` +
-                                `  4. Which model — claude-opus-4-7 (most capable), claude-sonnet-4-6 (balanced), or claude-haiku-4-5-20251001 (fastest). Leave model empty if the user doesn't care.\n` +
-                                `Most tricks need only one prompt step. Add steps only when the user explicitly wants a multi-step pipeline.\n` +
-                                `When the user says "save" or approves, output the final artifact block — don't try to save it yourself, the dashboard handles persistence.]\n\n`
-                            : `[BUILDER MODE: You are helping configure an artifact. Output structured JSON blocks as you build.]\n\n`;
-            enrichedMessage = builderPrefix + fileContext + toolContext + artifactContext + message;
-            builderSessionInited.add(sessionKey);
-        }
-        else {
-            enrichedMessage = fileContext + toolContext + artifactContext + message;
-        }
+        const sessionKey = builderSessionKey(artifactType, agentSlug);
         try {
             writeEvent('progress', { status: 'thinking…' });
             const gateway = await getGateway();
-            // Builder generates JSON artifacts — no tool calls. Pin to 'none'
-            // toolset so the SDK system prompt drops the tool inventory.
-            gateway.setSessionToolset(sessionKey, 'none');
+            const isFirstMessage = !gateway.assistant.getSdkSessionId(sessionKey);
+            const enrichedMessage = buildBuilderEnrichedMessage({
+                message,
+                artifactType,
+                agentSlug,
+                currentArtifact,
+                attachments,
+                linkedTools,
+                isFirstMessage,
+            });
             let lastText = '';
             const response = await gateway.handleMessage(sessionKey, enrichedMessage, async (text) => {
                 lastText = text ?? '';
@@ -8277,11 +8143,14 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
         }
     });
     // Reset builder session when user clicks "New"
-    app.post('/api/builder/reset', (_req, res) => {
+    app.post('/api/builder/reset', async (_req, res) => {
         const { artifactType, agentSlug } = _req.body;
-        const type = artifactType || 'skill';
-        const sessionKey = `dashboard:builder:${type}:${agentSlug || 'clementine'}`;
-        builderSessionInited.delete(sessionKey);
+        const sessionKey = builderSessionKey(artifactType, agentSlug);
+        // Clearing the SDK session ID is what makes the next turn detect
+        // as "first" and re-emit the system prefix. The per-process Set
+        // has been replaced by the persisted SDK session map.
+        const gateway = await getGateway();
+        gateway.assistant.clearSession(sessionKey);
         res.json({ ok: true });
     });
     // Test a skill by sending a trigger message through the gateway with skill context

package/dist/dashboard/builder/prompt.d.ts

@@ -0,0 +1,36 @@
+export type BuilderType = 'skill' | 'cron' | 'agent' | 'workflow';
+export interface BuildBuilderMessageOptions {
+    /** What the user typed in the chat box. */
+    message: string;
+    /** Type of artifact being drafted. Defaults to 'skill'. */
+    artifactType?: string;
+    /** When set, the artifact is scoped to this hired agent. */
+    agentSlug?: string;
+    /** Current artifact JSON the dashboard is holding. Re-sent each
+     *  turn so the agent has the live state in front of it. */
+    currentArtifact?: unknown;
+    /** Files the user dragged in for context. Each entry has a
+     *  filename + base64-encoded content. Decoded + capped per file. */
+    attachments?: Array<{
+        filename?: string;
+        content?: string;
+    }>;
+    /** Pre-selected MCP / local tool names the artifact should use. */
+    linkedTools?: string[];
+    /** Whether this is the first turn of a new conversation (no prior
+     *  SDK session). When true, the system prefix is included. */
+    isFirstMessage: boolean;
+}
+/**
+ * Compose the message that gets sent to gateway.handleMessage. The
+ * shape is: optional system prefix (first turn only), then file
+ * context, then linked-tools context, then current artifact state,
+ * then the user's literal message.
+ */
+export declare function buildBuilderEnrichedMessage(opts: BuildBuilderMessageOptions): string;
+/**
+ * Stable session-key for a builder conversation. Same key across
+ * /api/builder/chat and /api/builder/chat/stream so they share state.
+ */
+export declare function builderSessionKey(artifactType: string | undefined, agentSlug: string | undefined): string;
+//# sourceMappingURL=prompt.d.ts.map

package/dist/dashboard/builder/prompt.js

@@ -0,0 +1,118 @@
+/**
+ * Build the enriched user message the trick builder sends to the
+ * canonical chat path. Single source of truth shared by both
+ * /api/builder/chat and /api/builder/chat/stream.
+ *
+ * Two non-obvious things:
+ *
+ * 1. "First message" detection uses the SDK session ID, not an
+ *    in-memory Set. Daemon restart wipes in-memory state, so the
+ *    prior implementation re-sent the system prefix on the very next
+ *    turn even though SDK session resume kept the agent's memory of
+ *    it. Anchoring detection to the persisted SDK session means
+ *    the prefix is sent exactly once per genuine new conversation.
+ *
+ * 2. Model names referenced in the workflow prefix come from the
+ *    MODELS config so they don't rot when models advance.
+ */
+import { MODELS } from '../../config.js';
+const FILE_MAX_CHARS = 4000;
+function buildArtifactContext(currentArtifact) {
+    if (!currentArtifact)
+        return '';
+    return `\n[CURRENT ARTIFACT STATE]\n\`\`\`json-artifact\n${JSON.stringify(currentArtifact)}\n\`\`\`\n`;
+}
+function buildFileContext(attachments) {
+    if (!Array.isArray(attachments) || attachments.length === 0)
+        return '';
+    const parts = [];
+    for (const att of attachments) {
+        if (!att.filename || !att.content)
+            continue;
+        try {
+            const decoded = Buffer.from(att.content, 'base64').toString('utf-8');
+            const trimmed = decoded.length > FILE_MAX_CHARS
+                ? decoded.slice(0, FILE_MAX_CHARS) + '\n... (truncated)'
+                : decoded;
+            parts.push(`### ${att.filename}\n\`\`\`\n${trimmed}\n\`\`\``);
+        }
+        catch {
+            // Binary file; skip.
+        }
+    }
+    if (parts.length === 0)
+        return '';
+    return `\n[REFERENCE FILES — the user attached these for context]\n${parts.join('\n\n')}\n`;
+}
+function buildToolContext(linkedTools) {
+    if (!Array.isArray(linkedTools) || linkedTools.length === 0)
+        return '';
+    return `\n[LINKED TOOLS — this artifact should use these tools: ${linkedTools.join(', ')}]\n`;
+}
+function buildSystemPrefix(type, agentSlug) {
+    const agentContext = agentSlug
+        ? `You are building this for the agent "${agentSlug}". The artifact will be scoped to this agent specifically.\n`
+        : '';
+    if (type === 'skill') {
+        return `[BUILDER MODE: You are helping build a reusable skill. ${agentContext}As you develop the procedure, output the current state as a JSON block:\n` +
+            '```json-artifact\n{"type":"skill","title":"...","description":"...","triggers":["..."],"steps":"markdown procedure","toolsUsed":["tool1","tool2"]}\n```\n' +
+            `Update this block in EVERY response as the skill evolves. If the user has linked tools, include them in the toolsUsed array. Ask clarifying questions to refine the procedure. Keep it conversational — one question at a time. ` +
+            `When the user says "save" or approves, output the final artifact block.]\n\n`;
+    }
+    if (type === 'cron') {
+        return `[BUILDER MODE: You are helping build a scheduled cron job. ${agentContext}As you develop the job, output the current state as a JSON block:\n` +
+            '```json-artifact\n{"type":"cron","name":"...","schedule":"cron expression","tier":1,"prompt":"the full job prompt","enabled":true}\n```\n' +
+            `Update this block in EVERY response as the job evolves. Ask about schedule, what it should do, which tools/APIs it needs, and what tier (1=read-only, 2=read-write). ` +
+            `Cron jobs automatically pull in matching skills (learned procedures) at runtime. If the user describes a workflow that should be reusable, suggest creating it as a skill first, then building the cron job that references those trigger keywords.\n` +
+            `When the user says "save" or approves, output the final artifact block.]\n\n`;
+    }
+    if (type === 'agent') {
+        return `[BUILDER MODE: You are helping create a new AI agent team member. As you develop the agent config, output the current state as a JSON block:\n` +
+            '```json-artifact\n{"type":"agent","name":"...","description":"role description","model":"sonnet","personality":"system prompt / onboarding brief","tools":["tool1","tool2"],"channel":"","tier":2}\n```\n' +
+            `Update this block in EVERY response as the agent evolves. Ask about: the agent's role, what tools it needs, what model to use (haiku/sonnet/opus), its personality/system prompt, which channel it should operate in, and its security tier.\n` +
+            `Help the user think about what makes a good agent: clear role, specific tools, focused personality. Keep it conversational — one question at a time.\n` +
+            `When the user says "save" or approves, output the final artifact block.]\n\n`;
+    }
+    if (type === 'workflow') {
+        return `[BUILDER MODE: You are helping the user DRAFT a "trick" — a (possibly multi-step) thing Clementine can do on a schedule or on demand. You are NOT executing the trick. You are not running anything in the background. You are only authoring a spec the user will save, then run later from the dashboard.\n` +
+            `\n` +
+            `Hard rules:\n` +
+            `  - NEVER say "on it", "running in the background", "I'll follow up", "working on it now", or anything else that implies you're executing the user's request. You are drafting a spec.\n` +
+            `  - Stay strictly conversational. One short question per turn. Update the artifact block on every turn.\n` +
+            `  - If the user describes "real work" (multi-step actions, scrapers, enrichments, reports), still just draft it — don't dispatch.\n` +
+            `\n` +
+            `As you develop the trick, output the current state as a JSON block:\n` +
+            '```json-artifact\n{"type":"workflow","name":"...","description":"...","schedule":"","model":"","steps":"step1:\\n  prompt: ...\\nstep2:\\n  prompt: ...\\n  dependsOn: step1"}\n```\n' +
+            `Ask about (in roughly this order, one at a time):\n` +
+            `  1. The goal (one sentence is fine — confirm it back).\n` +
+            `  2. When it should run — natural language is fine ("every weekday at 9"); convert to a cron expression in the schedule field. Empty schedule = manual.\n` +
+            `  3. Which tools, projects, or channels she'll need (MCP servers, local CLIs like sf/gh/gcloud, Slack/Discord targets).\n` +
+            `  4. Which model — ${MODELS.opus} (most capable), ${MODELS.sonnet} (balanced), or ${MODELS.haiku} (fastest). Leave model empty if the user doesn't care.\n` +
+            `Most tricks need only one prompt step. Add steps only when the user explicitly wants a multi-step pipeline.\n` +
+            `When the user says "save" or approves, output the final artifact block — don't try to save it yourself, the dashboard handles persistence.]\n\n`;
+    }
+    return `[BUILDER MODE: You are helping configure an artifact. Output structured JSON blocks as you build.]\n\n`;
+}
+/**
+ * Compose the message that gets sent to gateway.handleMessage. The
+ * shape is: optional system prefix (first turn only), then file
+ * context, then linked-tools context, then current artifact state,
+ * then the user's literal message.
+ */
+export function buildBuilderEnrichedMessage(opts) {
+    const type = opts.artifactType || 'skill';
+    const fileContext = buildFileContext(opts.attachments);
+    const toolContext = buildToolContext(opts.linkedTools);
+    const artifactContext = buildArtifactContext(opts.currentArtifact);
+    const prefix = opts.isFirstMessage ? buildSystemPrefix(type, opts.agentSlug) : '';
+    return prefix + fileContext + toolContext + artifactContext + opts.message;
+}
+/**
+ * Stable session-key for a builder conversation. Same key across
+ * /api/builder/chat and /api/builder/chat/stream so they share state.
+ */
+export function builderSessionKey(artifactType, agentSlug) {
+    const type = artifactType || 'skill';
+    return `dashboard:builder:${type}:${agentSlug || 'clementine'}`;
+}
+//# sourceMappingURL=prompt.js.map

package/dist/gateway/router.js

@@ -1780,53 +1780,58 @@ export class Gateway {
                     const { runAgent } = await import('../agent/run-agent.js');
                     const { buildExtraMcpForRunAgent } = await import('../agent/run-agent-mcp.js');
                     const { buildChatSystemAppend } = await import('../agent/run-agent-context.js');
-                    // Wire Composio + external MCP servers (Outlook, Gmail,
-                    // Salesforce, etc) so chat can reach the same tools the
-                    // legacy chat path did. Profile allowlists override the
-                    // bundle router when set.
-                    //
-                    // Use originalText (not chatPrompt) for scope routing —
-                    // chatPrompt may have the partial-interrupt banner folded in,
-                    // which would skew bundle matching.
-                    const chatMcp = await buildExtraMcpForRunAgent({
-                        scopeText: originalText,
-                        profile: resolvedProfile,
-                    });
-                    // Inject vault context (SOUL.md / MEMORY.md / AGENTS.md +
-                    // optional profile body) into the system-prompt append so
-                    // the agent has personality + long-term memory + team
-                    // awareness. Profile-specific MEMORY.md takes precedence
-                    // over the global one when a hired agent is active.
-                    const chatSystemAppend = buildChatSystemAppend({
-                        profile: resolvedProfile,
-                        profileAppend: resolvedProfile?.systemPromptBody,
-                    });
-                    // Per-turn context — recall of recent transcripts, persistent
-                    // learnings, silent context blocks, security advisories, and
-                    // toolset directives accumulated above. This is what gives
-                    // continuity across daemon restarts (SDK in-memory session is
-                    // gone, but transcripts in SQLite persist; recall surfaces
-                    // them). Prefixed to the user message in a clearly-delimited
-                    // [Context] block so the model knows it's framing, not user
-                    // input.
-                    const turnContextPrefix = securityAnnotation.trim()
+                    // Builder sessions (dashboard trick/skill/cron/agent builder)
+                    // are conversational JSON-drafting flows, not real chat. They
+                    // don't need vault context, MCP tools, recall, or auto-memory
+                    // extraction — the builder prefix IS the system prompt and
+                    // the agent only emits json-artifact blocks. Strip everything
+                    // expensive; keep just SDK session resume so multi-turn
+                    // artifact iteration sees its own prior turns.
+                    const isBuilderSession = sessionKey.startsWith('dashboard:builder:');
+                    // Wire Composio + external MCP only for real chat. Builder
+                    // skips entirely — builder turns never call tools.
+                    const chatMcp = isBuilderSession
+                        ? null
+                        : await buildExtraMcpForRunAgent({
+                            scopeText: originalText,
+                            profile: resolvedProfile,
+                        });
+                    // Vault context (SOUL.md / MEMORY.md / AGENTS.md + optional
+                    // profile body) — real chat only. Builder gets just its own
+                    // prefix as the system prompt.
+                    const chatSystemAppend = isBuilderSession
+                        ? ''
+                        : buildChatSystemAppend({
+                            profile: resolvedProfile,
+                            profileAppend: resolvedProfile?.systemPromptBody,
+                        });
+                    // Per-turn context (recall + persistent learnings + silent
+                    // blocks + security/toolset directives) — real chat only.
+                    // Builder doesn't need recall of unrelated transcripts.
+                    const turnContextPrefix = !isBuilderSession && securityAnnotation.trim()
                         ? `[Context — read this for continuity, then respond to the user message below]\n${securityAnnotation}\n[/Context]\n\n`
                         : '';
                     const finalPrompt = turnContextPrefix + chatPrompt;
                     // Resume the prior SDK session when one exists for this
                     // sessionKey. The SDK persists session JSONLs to disk, so
-                    // resume works across daemon restarts. Without this, every
-                    // turn is a fresh SDK session with zero conversation history.
+                    // resume works across daemon restarts AND for builder
+                    // multi-turn artifact iteration.
                     const priorSdkSessionId = this.assistant.getSdkSessionId(effectiveSessionKey);
+                    // Builder cost knobs: Haiku is plenty for JSON drafting,
+                    // tight budget, no tools surfaced in the system prompt.
+                    const builderModel = isBuilderSession ? MODELS.haiku : effectiveModel;
+                    const builderBudget = isBuilderSession ? 0.10 : undefined;
+                    const builderAllowedTools = isBuilderSession ? [] : undefined;
                     logger.info({
                         sessionKey: effectiveSessionKey,
                         profile: resolvedProfile?.slug,
-                        path: 'runagent_chat',
-                        composioConnected: chatMcp.composioConnected.length,
-                        externalConnected: chatMcp.externalConnected.length,
+                        path: isBuilderSession ? 'runagent_builder' : 'runagent_chat',
+                        composioConnected: chatMcp?.composioConnected.length ?? 0,
+                        externalConnected: chatMcp?.externalConnected.length ?? 0,
                         systemAppendChars: chatSystemAppend.length,
                         turnContextChars: turnContextPrefix.length,
                         resumingSdkSessionId: priorSdkSessionId || null,
+                        isBuilderSession,
                     }, 'Routing chat through runAgent');
                     const runAgentResult = await runAgent(finalPrompt, {
                         sessionKey: effectiveSessionKey,
@@ -1834,11 +1839,13 @@ export class Gateway {
                         profile: resolvedProfile,
                         agentManager: this.getAgentManager(),
                         memoryStore: this.assistant.getMemoryStore?.() ?? null,
-                        ...(effectiveModel ? { model: effectiveModel } : {}),
+                        ...(builderModel ? { model: builderModel } : {}),
                         ...(maxTurns ? { maxTurns } : {}),
+                        ...(builderBudget !== undefined ? { maxBudgetUsd: builderBudget } : {}),
+                        ...(builderAllowedTools ? { allowedTools: builderAllowedTools } : {}),
                         ...(chatSystemAppend ? { systemPromptAppend: chatSystemAppend } : {}),
                         ...(priorSdkSessionId ? { resumeSessionId: priorSdkSessionId } : {}),
-                        extraMcpServers: chatMcp.servers,
+                        ...(chatMcp ? { extraMcpServers: chatMcp.servers } : {}),
                         onText: wrappedOnText,
                         onToolActivity: ({ tool, input }) => {
                             toolActivityCount++;
@@ -1856,9 +1863,11 @@ export class Gateway {
                     }
                     clearTimeout(chatTimer);
                     clearTimeout(hardWallTimer);
-                    // Mirror transcript so memory + recall continue working.
+                    // Mirror transcript so memory + recall continue working — but
+                    // skip for builder sessions since their turns are spec-drafting,
+                    // not real conversation worth recalling later.
                     const memoryStore = this.assistant.getMemoryStore?.();
-                    if (memoryStore) {
+                    if (memoryStore && !isBuilderSession) {
                         try {
                             memoryStore.saveTurn(effectiveSessionKey, 'user', originalText);
                             memoryStore.saveTurn(effectiveSessionKey, 'assistant', runAgentResult.text);
@@ -1867,10 +1876,13 @@ export class Gateway {
                             logger.debug({ err }, 'chat: transcript mirror failed (non-fatal)');
                         }
                     }
-                    // Fire auto-memory extraction in the background.
-                    this.assistant
-                        .triggerMemoryExtractionPostExchange(originalText, runAgentResult.text, effectiveSessionKey, resolvedProfile)
-                        .catch(err => logger.debug({ err, sessionKey: effectiveSessionKey }, 'chat: auto-memory failed (non-fatal)'));
+                    // Fire auto-memory extraction in the background — builder
+                    // turns are JSON-drafting noise, not memorable exchanges.
+                    if (!isBuilderSession) {
+                        this.assistant
+                            .triggerMemoryExtractionPostExchange(originalText, runAgentResult.text, effectiveSessionKey, resolvedProfile)
+                            .catch(err => logger.debug({ err, sessionKey: effectiveSessionKey }, 'chat: auto-memory failed (non-fatal)'));
+                    }
                     // Auth recovered if we got a clean response.
                     this.clearAuthFailure();
                     logger.info({

package/package.json

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