clementine-agent 1.18.52 → 1.18.54

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

@@ -14,4 +14,14 @@ export interface BuildChatContextOptions {
  * SDK then runs with just the bare `claude_code` preset.
  */
 export declare function buildChatSystemAppend(opts?: BuildChatContextOptions): string;
+/**
+ * Read the long-term memory block for an autonomous run (cron, team-task).
+ * Returns the agent-specific MEMORY.md when a hired agent is active, the
+ * global MEMORY.md when running as Clementine, or empty when neither
+ * exists. Returns a heading-prefixed block ready to drop into a prompt.
+ *
+ * Heartbeats deliberately skip this — they're tool-free Haiku decisions
+ * and a 6KB memory block defeats the cost economy.
+ */
+export declare function buildAutonomousMemoryContext(profile?: AgentProfile | null): string;
 //# sourceMappingURL=run-agent-context.d.ts.map

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

@@ -41,40 +41,70 @@ function trimTo(text, max) {
  */
 export function buildChatSystemAppend(opts = {}) {
     const blocks = [];
-    // 1. Soul (personality + voice)
-    const soul = readFileSafe(SOUL_FILE);
-    if (soul.trim()) {
-        blocks.push(`## Identity & Voice\n${trimTo(soul, SOUL_MAX_CHARS)}`);
+    const isHiredAgent = !!opts.profile && opts.profile.slug !== 'clementine';
+    // 1. Identity & Voice.
+    //    - Clementine main agent: SOUL.md (the global personality file).
+    //    - Hired agent main: their own profile.systemPromptBody IS their
+    //      identity — don't load Clementine's SOUL on top of it.
+    if (!isHiredAgent) {
+        const soul = readFileSafe(SOUL_FILE);
+        if (soul.trim()) {
+            blocks.push(`## Identity & Voice\n${trimTo(soul, SOUL_MAX_CHARS)}`);
+        }
     }
-    // 2. Long-term memory — agent-specific file overrides the global one.
-    const profileMemoryPath = opts.profile?.slug
+    // 2. Long-term memory — agent-specific file when a hired agent is
+    //    active, otherwise the global one.
+    const profileMemoryPath = isHiredAgent
         ? path.join(AGENTS_DIR, opts.profile.slug, 'MEMORY.md')
         : null;
-    let memory = '';
     if (profileMemoryPath && fs.existsSync(profileMemoryPath)) {
-        memory = readFileSafe(profileMemoryPath);
+        const memory = readFileSafe(profileMemoryPath);
         if (memory.trim()) {
-            blocks.push(`## Long-Term Memory (${opts.profile?.name ?? opts.profile?.slug})\n${trimTo(memory, PROFILE_MEMORY_MAX_CHARS)}`);
+            blocks.push(`## Long-Term Memory (${opts.profile.name ?? opts.profile.slug})\n${trimTo(memory, PROFILE_MEMORY_MAX_CHARS)}`);
         }
     }
     else {
-        memory = readFileSafe(MEMORY_FILE);
+        const memory = readFileSafe(MEMORY_FILE);
         if (memory.trim()) {
             blocks.push(`## Long-Term Memory\n${trimTo(memory, MEMORY_MAX_CHARS)}`);
         }
     }
     // 3. Team roster (only when not running AS a hired agent — Sasha
     //    doesn't need to be told who Sasha is).
-    if (!opts.profile) {
+    if (!isHiredAgent) {
         const agentsRoster = readFileSafe(AGENTS_FILE);
         if (agentsRoster.trim()) {
             blocks.push(`## Team Roster\n${trimTo(agentsRoster, AGENTS_MAX_CHARS)}`);
         }
     }
-    // 4. Profile system prompt body (e.g. Sasha's role description).
+    // 4. Profile system prompt body (the hired agent's identity + role).
     if (opts.profileAppend?.trim()) {
         blocks.push(opts.profileAppend);
     }
     return blocks.join('\n\n');
 }
+/**
+ * Read the long-term memory block for an autonomous run (cron, team-task).
+ * Returns the agent-specific MEMORY.md when a hired agent is active, the
+ * global MEMORY.md when running as Clementine, or empty when neither
+ * exists. Returns a heading-prefixed block ready to drop into a prompt.
+ *
+ * Heartbeats deliberately skip this — they're tool-free Haiku decisions
+ * and a 6KB memory block defeats the cost economy.
+ */
+export function buildAutonomousMemoryContext(profile) {
+    const isHiredAgent = !!profile && profile.slug !== 'clementine';
+    const memoryPath = isHiredAgent
+        ? path.join(AGENTS_DIR, profile.slug, 'MEMORY.md')
+        : MEMORY_FILE;
+    if (!fs.existsSync(memoryPath))
+        return '';
+    const memory = readFileSafe(memoryPath);
+    if (!memory.trim())
+        return '';
+    const label = isHiredAgent
+        ? `Long-Term Memory (${profile.name ?? profile.slug})`
+        : 'Long-Term Memory';
+    return `## ${label}\n${trimTo(memory, isHiredAgent ? PROFILE_MEMORY_MAX_CHARS : MEMORY_MAX_CHARS)}\n\n`;
+}
 //# sourceMappingURL=run-agent-context.js.map

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

@@ -20,6 +20,7 @@ import pino from 'pino';
 import { BASE_DIR, VAULT_DIR, CRON_PROGRESS_DIR, } from '../config.js';
 import { runAgent } from './run-agent.js';
 import { buildExtraMcpForRunAgent } from './run-agent-mcp.js';
+import { buildAutonomousMemoryContext } from './run-agent-context.js';
 import { listAllGoals } from '../tools/shared.js';
 const CRON_PROGRESS_PENDING_MAX_ITEMS = 20;
 const CRON_PROGRESS_NOTES_MAX_CHARS = 2000;
@@ -234,6 +235,10 @@ export async function runAgentCron(opts) {
     const agentSlug = opts.profile?.slug;
     const ownerName = process.env.OWNER_NAME ?? 'the user';
     // ── Compose context blocks (mirrors legacy runCronJob) ─────────────
+    // Memory block goes first so the agent reads its long-term context
+    // before the run-specific progress/goals/etc. For a hired agent
+    // (Ross/Sasha) this is their own MEMORY.md, not Clementine's global.
+    const memoryContext = buildAutonomousMemoryContext(opts.profile);
     const progressContext = buildProgressContext(opts.jobName);
     const goalContext = buildGoalContext(opts.jobName);
     const delegationContext = buildDelegationContext(agentSlug);
@@ -246,6 +251,7 @@ export async function runAgentCron(opts) {
     // spawns isolated sub-agents without a hand-rolled prompt directive.
     // Final prompt
     const builtPrompt = `[Scheduled task: ${opts.jobName}]\n\n` +
+        memoryContext +
         progressContext +
         goalContext +
         skillContext +

package/dist/agent/run-agent-team-task.js

@@ -17,15 +17,21 @@
 import pino from 'pino';
 import { runAgent } from './run-agent.js';
 import { buildExtraMcpForRunAgent } from './run-agent-mcp.js';
+import { buildAutonomousMemoryContext } from './run-agent-context.js';
 const logger = pino({ name: 'clementine.run-agent-team-task' });
 export async function runAgentTeamTask(opts) {
     const taskName = `team-msg:${opts.fromSlug}-to-${opts.profile.slug}`;
     const now = new Date();
     const timestamp = now.toISOString().slice(0, 16).replace('T', ' ');
+    // Inject the recipient's own long-term memory so they have context
+    // about prior work, preferences, and team relationships before
+    // processing the message.
+    const memoryContext = buildAutonomousMemoryContext(opts.profile);
     // Match the legacy phase-1 prompt shape so existing agent training
     // (Sasha/Ross/Nora) keeps responding the same way. Phases 2+ are no
     // longer needed — the SDK keeps the conversation in one session.
     const builtPrompt = `[TEAM MESSAGE from ${opts.fromName} (${opts.fromSlug}) — ${timestamp}]\n\n` +
+        memoryContext +
         `You received a direct message from a teammate. Process it fully and autonomously.\n\n` +
         `MESSAGE:\n${opts.content}\n\n` +
         `IMPORTANT:\n` +

package/dist/gateway/router.js

@@ -1801,6 +1801,23 @@ export class Gateway {
                         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()
+                        ? `[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.
+                    const priorSdkSessionId = this.assistant.getSdkSessionId(effectiveSessionKey);
                     logger.info({
                         sessionKey: effectiveSessionKey,
                         profile: resolvedProfile?.slug,
@@ -1808,8 +1825,10 @@ export class Gateway {
                         composioConnected: chatMcp.composioConnected.length,
                         externalConnected: chatMcp.externalConnected.length,
                         systemAppendChars: chatSystemAppend.length,
+                        turnContextChars: turnContextPrefix.length,
+                        resumingSdkSessionId: priorSdkSessionId || null,
                     }, 'Routing chat through runAgent');
-                    const runAgentResult = await runAgent(chatPrompt, {
+                    const runAgentResult = await runAgent(finalPrompt, {
                         sessionKey: effectiveSessionKey,
                         source: 'chat',
                         profile: resolvedProfile,
@@ -1818,6 +1837,7 @@ export class Gateway {
                         ...(effectiveModel ? { model: effectiveModel } : {}),
                         ...(maxTurns ? { maxTurns } : {}),
                         ...(chatSystemAppend ? { systemPromptAppend: chatSystemAppend } : {}),
+                        ...(priorSdkSessionId ? { resumeSessionId: priorSdkSessionId } : {}),
                         extraMcpServers: chatMcp.servers,
                         onText: wrappedOnText,
                         onToolActivity: ({ tool, input }) => {
@@ -1829,6 +1849,11 @@ 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.

package/package.json

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