clementine-agent 1.18.53 → 1.18.55

package/dist/agent/assistant.d.ts

@@ -179,6 +179,20 @@ export declare class PersonalAssistant {
     /** Fire-and-forget: extract a reusable skill from a successful execution. */
     private extractSkillFromExecution;
     private logMemoryExtractionSkip;
+    /**
+     * Public accessor for the SDK session ID associated with a sessionKey.
+     * Used by the canonical chat path so consecutive turns resume the
+     * same SDK conversation (the SDK persists sessions to JSONL on disk;
+     * resuming gives the agent native conversation history). Returns ''
+     * when no session exists yet.
+     */
+    getSdkSessionId(sessionKey: string): string;
+    /**
+     * Persist the SDK session ID for a sessionKey. Called after a runAgent
+     * call returns so the next call can resume the same conversation.
+     * Writes through to disk via the existing saveSessions plumbing.
+     */
+    setSdkSessionId(sessionKey: string, sdkSessionId: string): void;
     /**
      * Public entry point for triggering auto-memory extraction after an
      * exchange. Used by the new runAgent chat path (Phase 2 migration)

package/dist/agent/assistant.js

@@ -2681,6 +2681,28 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         }
         catch { /* telemetry only */ }
     }
+    /**
+     * Public accessor for the SDK session ID associated with a sessionKey.
+     * Used by the canonical chat path so consecutive turns resume the
+     * same SDK conversation (the SDK persists sessions to JSONL on disk;
+     * resuming gives the agent native conversation history). Returns ''
+     * when no session exists yet.
+     */
+    getSdkSessionId(sessionKey) {
+        return this.sessions.get(sessionKey) ?? '';
+    }
+    /**
+     * Persist the SDK session ID for a sessionKey. Called after a runAgent
+     * call returns so the next call can resume the same conversation.
+     * Writes through to disk via the existing saveSessions plumbing.
+     */
+    setSdkSessionId(sessionKey, sdkSessionId) {
+        if (!sdkSessionId)
+            return;
+        this.sessions.set(sessionKey, sdkSessionId);
+        this.sessionTimestamps.set(sessionKey, new Date());
+        this.saveSessions();
+    }
     /**
      * Public entry point for triggering auto-memory extraction after an
      * exchange. Used by the new runAgent chat path (Phase 2 migration)

package/dist/gateway/router.js

@@ -1780,45 +1780,72 @@ 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,
-                    });
+                    // 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 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(chatPrompt, {
+                    const runAgentResult = await runAgent(finalPrompt, {
                         sessionKey: effectiveSessionKey,
                         source: 'chat',
                         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 } : {}),
-                        extraMcpServers: chatMcp.servers,
+                        ...(priorSdkSessionId ? { resumeSessionId: priorSdkSessionId } : {}),
+                        ...(chatMcp ? { extraMcpServers: chatMcp.servers } : {}),
                         onText: wrappedOnText,
                         onToolActivity: ({ tool, input }) => {
                             toolActivityCount++;
@@ -1829,11 +1856,18 @@ export class Gateway {
                         },
                         abortSignal: chatAc.signal,
                     });
+                    // Persist the SDK session ID so the next turn resumes the
+                    // same conversation. Survives daemon restarts via SESSIONS_FILE.
+                    if (runAgentResult.sessionId) {
+                        this.assistant.setSdkSessionId(effectiveSessionKey, runAgentResult.sessionId);
+                    }
                     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);
@@ -1842,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.53",
+  "version": "1.18.55",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",