clementine-agent 1.18.55 → 1.18.57

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
@@ -26037,10 +25906,10 @@ function renderBuilderPreview(artifact, type) {
       + '<option value="2"' + (artifact.tier === 2 ? ' selected' : '') + '>2 — Read+Write</option>'
       + '<option value="3"' + (artifact.tier === 3 ? ' selected' : '') + '>3 — Full</option>'
       + '</select></div>'
-      + '<div class="preview-field"><label>Mode</label><select onchange="builderArtifact.mode=this.value">'
-      + '<option value="standard"' + (artifact.mode !== 'unleashed' ? ' selected' : '') + '>Standard</option>'
-      + '<option value="unleashed"' + (artifact.mode === 'unleashed' ? ' selected' : '') + '>Unleashed</option>'
-      + '</select></div>'
+      + '<div class="preview-field"><label>Linked Tools</label>'
+      + '<div id="builder-tools-panel" style="max-height:180px;overflow-y:auto;border:1px solid var(--border);border-radius:6px;padding:6px 8px;background:var(--bg-primary);margin-bottom:4px"></div>'
+      + '<div style="font-size:10px;color:var(--text-muted)">Pick tools the cron should use. The chat sees these as a hint, and they steer how the prompt is written.</div>'
+      + '</div>'
       + '<div class="preview-field"><label>Prompt</label><textarea rows="12" onchange="builderArtifact.prompt=this.value">' + esc(artifact.prompt || '') + '</textarea></div>'
       + '<div class="preview-field"><label>Reference Files</label>'
       + '<div id="builder-attachments-list"></div>'
@@ -26050,6 +25919,7 @@ function renderBuilderPreview(artifact, type) {
       + '</label>'
       + '<div style="font-size:10px;color:var(--text-muted);margin-top:4px">Files injected into the agent prompt at runtime</div>'
       + '</div>';
+    setTimeout(function() { loadBuilderToolOptions(artifact.toolsUsed || _builderLinkedTools); }, 50);
   } else if (type === 'agent') {
     html = '<div class="preview-field"><label>Name</label><input type="text" value="' + esc(artifact.name || '') + '" onchange="builderArtifact.name=this.value"></div>'
       + '<div class="preview-field"><label>Description / Role</label><input type="text" value="' + esc(artifact.description || '') + '" onchange="builderArtifact.description=this.value"></div>'
@@ -26060,13 +25930,22 @@ function renderBuilderPreview(artifact, type) {
       + '<option value="opus"' + (artifact.model === 'opus' ? ' selected' : '') + '>Opus</option>'
       + '</select></div>'
       + '<div class="preview-field"><label>Personality / System Prompt</label><textarea rows="8" onchange="builderArtifact.personality=this.value">' + esc(artifact.personality || '') + '</textarea></div>'
-      + '<div class="preview-field"><label>Tools (comma-separated)</label><input type="text" value="' + esc((artifact.tools || []).join(', ')) + '" onchange="builderArtifact.tools=this.value.split(\\x27,\\x27).map(function(t){return t.trim()}).filter(Boolean)"></div>'
+      + '<div class="preview-field"><label>Allowed Tools</label>'
+      + '<div id="builder-tools-panel" style="max-height:180px;overflow-y:auto;border:1px solid var(--border);border-radius:6px;padding:6px 8px;background:var(--bg-primary);margin-bottom:4px"></div>'
+      + '<div style="font-size:10px;color:var(--text-muted)">These become the agent\\x27s allowedTools — they\\x27re honored at the main-agent level when this agent runs as a profile.</div>'
+      + '</div>'
       + '<div class="preview-field"><label>Channel</label><input type="text" value="' + esc(artifact.channel || '') + '" onchange="builderArtifact.channel=this.value" placeholder="e.g. discord, slack"></div>';
+    setTimeout(function() { loadBuilderToolOptions(artifact.tools || _builderLinkedTools); }, 50);
   } else if (type === 'workflow') {
     html = '<div class="preview-field"><label>Workflow Name</label><input type="text" value="' + esc(artifact.name || '') + '" onchange="builderArtifact.name=this.value"></div>'
       + '<div class="preview-field"><label>Description</label><input type="text" value="' + esc(artifact.description || '') + '" onchange="builderArtifact.description=this.value"></div>'
       + '<div class="preview-field"><label>Trigger Schedule (cron, optional)</label><input type="text" value="' + esc(artifact.schedule || '') + '" onchange="builderArtifact.schedule=this.value" placeholder="e.g. 0 9 * * 1 (Mondays at 9am)"></div>'
+      + '<div class="preview-field"><label>Linked Tools</label>'
+      + '<div id="builder-tools-panel" style="max-height:180px;overflow-y:auto;border:1px solid var(--border);border-radius:6px;padding:6px 8px;background:var(--bg-primary);margin-bottom:4px"></div>'
+      + '<div style="font-size:10px;color:var(--text-muted)">Tools the trick will use. The chat sees these as a hint and weaves them into the steps.</div>'
+      + '</div>'
       + '<div class="preview-field"><label>Steps (YAML/Markdown)</label><textarea rows="14" onchange="builderArtifact.steps=this.value">' + esc(artifact.steps || '') + '</textarea></div>';
+    setTimeout(function() { loadBuilderToolOptions(artifact.toolsUsed || _builderLinkedTools); }, 50);
   }
   preview.innerHTML = html;
   // Load existing attachments if editing
@@ -26124,8 +26003,13 @@ async function saveBuilderArtifact() {
   var type = document.getElementById('builder-type').value;
   try {
     var agentSlug = (document.getElementById('builder-agent') || {}).value || '';
-    // Sync linked tools into artifact before saving
-    if (type === 'skill') builderArtifact.toolsUsed = _builderLinkedTools;
+    // Sync linked tools into artifact before saving — picker is shared
+    // across types but the persisted field name differs.
+    if (type === 'agent') {
+      builderArtifact.tools = _builderLinkedTools;
+    } else {
+      builderArtifact.toolsUsed = _builderLinkedTools;
+    }
     var r = await apiJson('POST', '/api/builder/save', {
       artifactType: type,
       artifact: builderArtifact,
@@ -26212,8 +26096,18 @@ async function loadBuilderToolOptions(selectedTools) {
 
 function syncBuilderLinkedTools() {
   _builderLinkedTools = Array.from(document.querySelectorAll('.builder-tool-cb:checked')).map(function(cb) { return cb.value; });
-  // Also sync into the artifact so it saves with toolsUsed
-  if (builderArtifact) builderArtifact.toolsUsed = _builderLinkedTools;
+  if (!builderArtifact) return;
+  // Field name differs per artifact type: agent stores into "tools"
+  // (which becomes profile.team.allowedTools on save). Skill, cron and
+  // workflow store into "toolsUsed" — carried for reference, since the
+  // runtime LINKED TOOLS context block is rebuilt from picker state
+  // each turn.
+  var type = (document.getElementById('builder-type') || {}).value;
+  if (type === 'agent') {
+    builderArtifact.tools = _builderLinkedTools;
+  } else {
+    builderArtifact.toolsUsed = _builderLinkedTools;
+  }
 }
 
 // ── Builder File Attachments ──────────────

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/package.json

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