clementine-agent 1.18.179 → 1.18.181

package/dist/agent/assistant.js

@@ -1208,6 +1208,8 @@ Obsidian vault with YAML frontmatter, [[wikilinks]], #tags.
 **Remembering:** Durable facts → memory_write(action="update_memory"). Daily context → note_take / memory_write(action="append_daily"). New person → note_create. New task → task_add.
 Save important facts immediately; a background agent also extracts after each exchange.
 
+**Recalling — REQUIRED behavior:** When the user references past work you don't have in immediate context — a URL, a deployment, a file you created, a task or background job you ran, a person/project/domain name you don't have inline — call \`memory_search\` (or \`transcript_search\` for chat history) BEFORE asking the user to provide it and BEFORE replying that you have no record. Saying "I don't see any record of that" without having searched is a memory failure, not an honest answer. Background tasks, cron runs, deployments, and prior chat turns are all in the SQLite memory store with dense embeddings — semantic search will surface them even when the wording doesn't match exactly.
+
 ## Self-Configuration (never tell ${owner} to edit a config file)
 
 Clementine is self-configuring. Every credential, every integration, every tool permission can be set by calling a tool — no hand-editing.

package/dist/agent/background-tasks.d.ts

@@ -64,6 +64,26 @@ export declare function resumeBackgroundTask(id: string, opts?: BackgroundTaskOp
 export declare function interruptStaleRunningTasks(opts?: BackgroundTaskOptions): number;
 /** Backward-compatible export for callers/tests using the old name. */
 export declare const abortStaleRunningTasks: typeof interruptStaleRunningTasks;
+/**
+ * Find background tasks whose lifecycle messages were never mirrored into
+ * the originating chat session's memory — typically because they completed
+ * before 1.18.180 wired the mirror, or because the daemon was down when the
+ * delivery would have fired. Returns terminal-state tasks (done / failed /
+ * interrupted / aborted) that:
+ *   - have a sessionKey (so we know where to mirror them)
+ *   - lack a `mirroredAt` flag (haven't been mirrored yet)
+ *   - completed within the recency window (default: last 7 days)
+ *
+ * Caller (typically the cron-scheduler on daemon start) is responsible for
+ * doing the actual mirror via gateway.injectContext and then stamping each
+ * task with `markBackgroundTaskMirrored(id)`. Keeping the injection out of
+ * this module avoids a dependency cycle on the gateway.
+ */
+export declare function findUnmirroredDeliveries(opts?: BackgroundTaskOptions & {
+    sinceMs?: number;
+}): BackgroundTask[];
+/** Stamp `mirroredAt` so future boots don't re-mirror the same delivery. */
+export declare function markBackgroundTaskMirrored(id: string, opts?: BackgroundTaskOptions): void;
 /** Delete a task file. Callers should avoid deleting active tasks. */
 export declare function deleteBackgroundTask(id: string, opts?: BackgroundTaskOptions): void;
 /** Backward-compatible test helper alias. */

package/dist/agent/background-tasks.js

@@ -205,6 +205,49 @@ export function interruptStaleRunningTasks(opts) {
 }
 /** Backward-compatible export for callers/tests using the old name. */
 export const abortStaleRunningTasks = interruptStaleRunningTasks;
+/**
+ * Find background tasks whose lifecycle messages were never mirrored into
+ * the originating chat session's memory — typically because they completed
+ * before 1.18.180 wired the mirror, or because the daemon was down when the
+ * delivery would have fired. Returns terminal-state tasks (done / failed /
+ * interrupted / aborted) that:
+ *   - have a sessionKey (so we know where to mirror them)
+ *   - lack a `mirroredAt` flag (haven't been mirrored yet)
+ *   - completed within the recency window (default: last 7 days)
+ *
+ * Caller (typically the cron-scheduler on daemon start) is responsible for
+ * doing the actual mirror via gateway.injectContext and then stamping each
+ * task with `markBackgroundTaskMirrored(id)`. Keeping the injection out of
+ * this module avoids a dependency cycle on the gateway.
+ */
+export function findUnmirroredDeliveries(opts) {
+    const sinceMs = opts?.sinceMs ?? 7 * 24 * 60 * 60_000;
+    const cutoff = Date.now() - sinceMs;
+    const terminal = ['done', 'failed', 'interrupted', 'aborted'];
+    const out = [];
+    for (const status of terminal) {
+        for (const task of listBackgroundTasks({ status }, opts)) {
+            if (task.mirroredAt)
+                continue; // already mirrored on a prior boot
+            if (!task.sessionKey)
+                continue; // no chat to mirror back to
+            const stampIso = task.completedAt ?? task.interruptedAt ?? task.createdAt;
+            const stamp = Date.parse(stampIso ?? '');
+            if (Number.isFinite(stamp) && stamp < cutoff)
+                continue;
+            out.push(task);
+        }
+    }
+    return out;
+}
+/** Stamp `mirroredAt` so future boots don't re-mirror the same delivery. */
+export function markBackgroundTaskMirrored(id, opts) {
+    const task = loadBackgroundTask(id, opts);
+    if (!task)
+        return;
+    task.mirroredAt = new Date().toISOString();
+    safeWrite(pathFor(id, opts), task);
+}
 /** Delete a task file. Callers should avoid deleting active tasks. */
 export function deleteBackgroundTask(id, opts) {
     try {

package/dist/gateway/cron-scheduler.d.ts

@@ -186,6 +186,30 @@ export declare class CronScheduler {
      */
     private dispatchContextForJobName;
     private dispatchContextForBackgroundTask;
+    /**
+     * Mirror a background-task message (start / done / failed) into the
+     * originating chat session's memory. Without this, bg: tasks finish,
+     * deliver their result to Discord/Slack, and then the very next chat
+     * turn comes back to an assistant that has zero memory of any of it —
+     * the user asks "fix the site you just deployed" and gets "I don't see
+     * any record of a Netlify site." injectContext writes into both the
+     * pending-context map (visible to the next SDK turn) and the memory
+     * store (searchable later by the assistant).
+     *
+     * If `taskId` is provided, stamps the task with `mirroredAt` so the
+     * startup backfill won't replay it on the next daemon restart.
+     */
+    private mirrorBackgroundTaskToChat;
+    /**
+     * Boot-time backfill. Mirrors any terminal-state background task whose
+     * lifecycle message never landed in the originating chat session's
+     * memory — typically because it finished before 1.18.180 wired the
+     * mirror, or because the daemon was down when delivery would have
+     * fired. Idempotent via the `mirroredAt` flag on each task file.
+     */
+    mirrorOrphanedBackgroundDeliveries(): {
+        mirrored: number;
+    };
     /** Same idea for workflows. Workflows can be agent-scoped via WorkflowDefinition.agentSlug. */
     private dispatchContextForWorkflow;
     private runJob;

package/dist/gateway/cron-scheduler.js

@@ -39,7 +39,7 @@ import { parseAllWorkflows as parseAllWorkflowsSync } from '../agent/workflow-ru
 import { SelfImproveLoop } from '../agent/self-improve.js';
 import { loadPromptOverridesForJob, watchPromptOverrides } from '../agent/prompt-overrides/loader.js';
 import { logAuditJsonl } from '../agent/hooks.js';
-import { listBackgroundTasks, loadBackgroundTask, markDone as markBgTaskDone, markFailed as markBgTaskFailed, markRunning as markBgTaskRunning, updateBackgroundTask, } from '../agent/background-tasks.js';
+import { findUnmirroredDeliveries, listBackgroundTasks, loadBackgroundTask, markBackgroundTaskMirrored, markDone as markBgTaskDone, markFailed as markBgTaskFailed, markRunning as markBgTaskRunning, updateBackgroundTask, } from '../agent/background-tasks.js';
 import { outcomeStatusFromGoalDisposition, recentDecisions, recordDecisionOutcome, } from '../agent/proactive-ledger.js';
 import { formatCreditBlock, getBackgroundCreditBlock, isCreditBalanceError, markBackgroundCreditBlocked, } from './credit-guard.js';
 import { isRunHealthFailure } from './job-health.js';
@@ -944,6 +944,69 @@ export class CronScheduler {
             ctx.agentSlug = task.fromAgent;
         return ctx;
     }
+    /**
+     * Mirror a background-task message (start / done / failed) into the
+     * originating chat session's memory. Without this, bg: tasks finish,
+     * deliver their result to Discord/Slack, and then the very next chat
+     * turn comes back to an assistant that has zero memory of any of it —
+     * the user asks "fix the site you just deployed" and gets "I don't see
+     * any record of a Netlify site." injectContext writes into both the
+     * pending-context map (visible to the next SDK turn) and the memory
+     * store (searchable later by the assistant).
+     *
+     * If `taskId` is provided, stamps the task with `mirroredAt` so the
+     * startup backfill won't replay it on the next daemon restart.
+     */
+    mirrorBackgroundTaskToChat(sessionKey, userTextPlaceholder, assistantText, taskId) {
+        if (!sessionKey)
+            return;
+        try {
+            this.gateway.injectContext(sessionKey, userTextPlaceholder, assistantText, {
+                pending: false,
+                model: 'bg-task',
+                countExchange: true,
+            });
+            if (taskId) {
+                try {
+                    markBackgroundTaskMirrored(taskId);
+                }
+                catch { /* non-fatal */ }
+            }
+        }
+        catch (err) {
+            logger.debug({ err, sessionKey }, 'Failed to mirror background task message into chat memory');
+        }
+    }
+    /**
+     * Boot-time backfill. Mirrors any terminal-state background task whose
+     * lifecycle message never landed in the originating chat session's
+     * memory — typically because it finished before 1.18.180 wired the
+     * mirror, or because the daemon was down when delivery would have
+     * fired. Idempotent via the `mirroredAt` flag on each task file.
+     */
+    mirrorOrphanedBackgroundDeliveries() {
+        let mirrored = 0;
+        try {
+            for (const task of findUnmirroredDeliveries()) {
+                const promptSnippet = (task.prompt ?? '').slice(0, 200);
+                const headSummary = `${task.id} (${task.status})`;
+                const body = (task.result ?? task.error ?? '(no saved output)').slice(0, 1500);
+                const placeholder = `[Background task ${headSummary} delivered: ${promptSnippet}]`;
+                const message = task.status === 'done'
+                    ? `**Background task ${task.id} done** — ${promptSnippet}\n\n${body}`
+                    : `**Background task ${task.id} ${task.status}** — ${promptSnippet}\n\n${body}`;
+                this.mirrorBackgroundTaskToChat(task.sessionKey, placeholder, message, task.id);
+                mirrored++;
+            }
+            if (mirrored > 0) {
+                logger.info({ mirrored }, 'Mirrored orphaned background task deliveries into chat memory');
+            }
+        }
+        catch (err) {
+            logger.warn({ err }, 'Background-task backfill failed — non-fatal');
+        }
+        return { mirrored };
+    }
     /** Same idea for workflows. Workflows can be agent-scoped via WorkflowDefinition.agentSlug. */
     dispatchContextForWorkflow(name) {
         const wf = this.workflowDefs.find(w => w.name === name);
@@ -1915,9 +1978,18 @@ export class CronScheduler {
                 lastNotifiedAt: new Date().toISOString(),
                 progressMessageCount: 0,
             });
+            const startMessage = `**Background task ${started.id} started** — ${started.prompt.slice(0, 120).replace(/\s+/g, ' ')}${started.prompt.length > 120 ? '...' : ''}\n\nI'll update you every 15 minutes or when it finishes.`;
             this.dispatcher
-                .send(`**Background task ${started.id} started** — ${started.prompt.slice(0, 120).replace(/\s+/g, ' ')}${started.prompt.length > 120 ? '...' : ''}\n\nI'll update you every 15 minutes or when it finishes.`, this.dispatchContextForBackgroundTask(started))
+                .send(startMessage, this.dispatchContextForBackgroundTask(started))
                 .catch((err) => logger.debug({ err, id: started.id }, 'Failed to dispatch background task start'));
+            // Mirror the start announcement into the originating chat session's
+            // memory so the assistant remembers it has a task running. Without
+            // this, the next chat turn the user sends comes back to a session
+            // that has no idea any bg: work was ever queued.
+            // Note: we do NOT stamp `mirroredAt` here — that's reserved for the
+            // terminal-state mirror (done/failed) so the backfill only counts
+            // deliveries, not intent-to-run.
+            this.mirrorBackgroundTaskToChat(started.sessionKey, `[Background task ${started.id} queued: ${started.prompt.slice(0, 200)}]`, startMessage);
             // Don't await — fire-and-forget. The 3s tick continues to scan.
             const maxHours = Math.max(0.05, started.maxMinutes / 60);
             const progressTimer = setInterval(() => {
@@ -1956,9 +2028,16 @@ export class CronScheduler {
                 const completed = loadBackgroundTask(started.id) ?? started;
                 const deliveryHead = `**Background task ${started.id} done** — ${started.prompt.slice(0, 100).replace(/\s+/g, ' ')}${started.prompt.length > 100 ? '...' : ''}\n\n`;
                 const body = (result ?? '').slice(0, 1500);
+                const deliveryMessage = deliveryHead + body;
                 this.dispatcher
-                    .send(deliveryHead + body, this.dispatchContextForBackgroundTask(completed))
+                    .send(deliveryMessage, this.dispatchContextForBackgroundTask(completed))
                     .catch((err) => logger.debug({ err, id: started.id }, 'Failed to dispatch background task result'));
+                // Mirror into chat memory so a follow-up like "fix the site"
+                // doesn't get a blank stare — the assistant needs to remember
+                // it just deployed something and where it lives. Stamp
+                // `mirroredAt` so the startup backfill won't replay this on the
+                // next restart.
+                this.mirrorBackgroundTaskToChat(completed.sessionKey, `[Background task ${completed.id} delivered: ${started.prompt.slice(0, 200)}]`, deliveryMessage, completed.id);
             }).catch((err) => {
                 clearInterval(progressTimer);
                 const errStr = String(err).slice(0, 500);
@@ -1969,9 +2048,13 @@ export class CronScheduler {
                     logger.warn({ err: saveErr, id: started.id }, 'Failed to mark background task failed');
                 }
                 const failed = loadBackgroundTask(started.id) ?? started;
+                const failMessage = `**Background task ${started.id} failed** — ${errStr.slice(0, 200)}`;
                 this.dispatcher
-                    .send(`**Background task ${started.id} failed** — ${errStr.slice(0, 200)}`, this.dispatchContextForBackgroundTask(failed))
+                    .send(failMessage, this.dispatchContextForBackgroundTask(failed))
                     .catch(() => { });
+                // Mirror failures too — the next chat turn should know the task
+                // died rather than silently pretending it never happened.
+                this.mirrorBackgroundTaskToChat(failed.sessionKey, `[Background task ${failed.id} failed: ${started.prompt.slice(0, 200)}]`, failMessage, failed.id);
             });
         }
     }
@@ -2353,6 +2436,14 @@ export class CronScheduler {
             const response = await this.gateway.handleWorkflow(wf, inputs ?? {});
             if (response && response !== '*(workflow completed — no output)*') {
                 await this.dispatcher.send(`**[Workflow: ${name}]**\n\n${response.slice(0, 1500)}`, this.dispatchContextForWorkflow(name));
+                // Mirror under a workflow-scoped session so semantic search can
+                // surface this run regardless of who triggered it.
+                try {
+                    this.gateway.injectContext(`workflow:${name}`, `[Workflow ${name} ran]`, response, { pending: false, model: 'workflow', countExchange: true });
+                }
+                catch (err) {
+                    logger.debug({ err, workflow: name }, 'workflow transcript mirror failed (non-fatal)');
+                }
                 // Inject into owner's DM session
                 if (DISCORD_OWNER_ID && DISCORD_OWNER_ID !== '0') {
                     this.gateway.injectContext(`discord:user:${DISCORD_OWNER_ID}`, `[Workflow: ${name}]`, response);
@@ -2366,6 +2457,14 @@ export class CronScheduler {
             logger.error({ err, workflow: name }, `Workflow '${name}' failed`);
             const errMsg = `Workflow '${name}' failed: ${String(err).slice(0, 300)}`;
             await this.dispatcher.send(errMsg, this.dispatchContextForWorkflow(name));
+            // Mirror failures into memory too — "what happened to that workflow?"
+            // should find something instead of nothing.
+            try {
+                this.gateway.injectContext(`workflow:${name}`, `[Workflow ${name} failed]`, errMsg, { pending: false, model: 'workflow', countExchange: true });
+            }
+            catch (mirrorErr) {
+                logger.debug({ err: mirrorErr, workflow: name }, 'workflow failure mirror failed (non-fatal)');
+            }
             return errMsg;
         }
         finally {

package/dist/index.js

@@ -901,6 +901,20 @@ async function asyncMain() {
     catch (err) {
         logger.warn({ err }, 'Background task hygiene check failed — non-fatal');
     }
+    // Backfill orphaned bg-task deliveries into chat memory. Picks up any
+    // task that finished in the last 7 days whose lifecycle message was
+    // never mirrored (e.g. completed before 1.18.180 wired the mirror, or
+    // while the daemon was down). Idempotent via the `mirroredAt` flag on
+    // each task file — safe to run on every boot.
+    try {
+        const result = cronScheduler.mirrorOrphanedBackgroundDeliveries();
+        if (result.mirrored > 0) {
+            logger.info({ count: result.mirrored }, 'Backfilled orphaned background task deliveries into chat memory');
+        }
+    }
+    catch (err) {
+        logger.warn({ err }, 'Background-task delivery backfill failed — non-fatal');
+    }
     const timerInterval = startTimerChecker(dispatcher, gateway);
     // Start brain ingest scheduler (polls registered REST sources on their cron)
     try {

package/dist/types.d.ts

@@ -295,6 +295,7 @@ export interface BackgroundTask {
     resultPath?: string;
     error?: string;
     deliverableNote?: string;
+    mirroredAt?: string;
 }
 /**
  * State for one specialist agent's heartbeat scheduler. Persisted at

package/package.json

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