clementine-agent 1.0.21 → 1.0.23

package/dist/gateway/router.d.ts

@@ -53,6 +53,14 @@ export declare class Gateway {
      * Falls back to pushing rawResult directly if the agent call fails.
      */
     private _deliverDeepResult;
+    /**
+     * For Clementine-owned sessions, classify whether the message should be
+     * delegated to a specialist agent. Returns null when routing isn't
+     * eligible; { delegated: true, ackMessage } when auto-delegated;
+     * { delegated: false, softSuggest } when only suggesting.
+     */
+    static routeAuditLogPath(): string;
+    private _maybeRouteToSpecialist;
     private _agentManager?;
     private _teamRouter?;
     private _teamBus?;
@@ -215,4 +223,15 @@ export declare class Gateway {
     /** Extract a procedural skill from a successful cron execution (fire-and-forget). */
     extractCronSkill(jobName: string, prompt: string, output: string, durationMs: number, agentSlug?: string): Promise<void>;
 }
+interface RouteAuditEntry {
+    timestamp: string;
+    sessionKey: string;
+    messageSnippet: string;
+    targetAgent: string;
+    confidence: number;
+    reasoning: string;
+    action: 'auto-delegated' | 'soft-suggested' | 'stayed-with-clementine';
+}
+export declare function getRecentRouteDecisions(limit?: number): RouteAuditEntry[];
+export {};
 //# sourceMappingURL=router.d.ts.map

package/dist/gateway/router.js

@@ -205,6 +205,67 @@ export class Gateway {
             }
         }
     }
+    /**
+     * For Clementine-owned sessions, classify whether the message should be
+     * delegated to a specialist agent. Returns null when routing isn't
+     * eligible; { delegated: true, ackMessage } when auto-delegated;
+     * { delegated: false, softSuggest } when only suggesting.
+     */
+    static routeAuditLogPath() {
+        return path.join(BASE_DIR, 'routing-audit.jsonl');
+    }
+    async _maybeRouteToSpecialist(sessionKey, text, onText) {
+        try {
+            const { isRoutable, classifyRoute } = await import('../agent/route-classifier.js');
+            // Fetch team roster and build the set of agent slugs for the routing gate
+            const agentMgr = this.getAgentManager();
+            const agents = agentMgr.listAll();
+            const ownerAgentSlugs = new Set(agents.filter(a => a.slug !== 'clementine').map(a => a.slug));
+            if (!isRoutable(sessionKey, ownerAgentSlugs))
+                return null;
+            if (ownerAgentSlugs.size === 0)
+                return null; // no team to route to
+            const decision = await classifyRoute(text, agents, this);
+            if (!decision)
+                return null;
+            logRouteDecision({ sessionKey, message: text, decision });
+            if (decision.targetAgent === 'clementine')
+                return null;
+            const targetProfile = agents.find(a => a.slug === decision.targetAgent);
+            if (!targetProfile)
+                return null;
+            // Auto-delegate at high confidence
+            if (decision.confidence >= 0.8) {
+                // Fire the team task in the background; ack immediately.
+                const ackMessage = `Routing this to **${targetProfile.name}** (${decision.reasoning.toLowerCase()}). I'll post their response back here when done.`;
+                onText?.(ackMessage).catch(() => { });
+                this.handleTeamTask('Clementine', 'clementine', text, targetProfile)
+                    .then(response => {
+                    if (!response)
+                        return;
+                    const delivery = `**${targetProfile.name}**: ${response}`;
+                    return this._dispatcher?.send(delivery, { sessionKey });
+                })
+                    .catch(err => {
+                    logger.warn({ err, target: decision.targetAgent }, 'Delegated task failed');
+                    void this._dispatcher?.send(`**${targetProfile.name}** hit an error handling that: ${String(err).slice(0, 200)}`, { sessionKey });
+                });
+                return { delegated: true, ackMessage };
+            }
+            // Soft-suggest at medium confidence
+            if (decision.confidence >= 0.5) {
+                return {
+                    delegated: false,
+                    softSuggest: `[Routing suggestion: This looks like it could be ${targetProfile.name}'s domain (${decision.reasoning}). If you want to delegate, reply "send to ${targetProfile.name}" or address them directly. Otherwise I'll handle it.]`,
+                };
+            }
+            return null; // low confidence — stay with Clementine silently
+        }
+        catch (err) {
+            logger.debug({ err, sessionKey }, 'Team routing attempt failed (non-fatal)');
+            return null;
+        }
+    }
     // Team system (lazy-initialized)
     _agentManager;
     _teamRouter;
@@ -676,6 +737,48 @@ export class Gateway {
                 // Use per-message override, then session default, then global default
                 const sess = this.sessions.get(sessionKey);
                 const effectiveModel = model ?? sess?.model;
+                // ── Team routing (Clementine-owned sessions only) ──────────────
+                // If the user is talking TO Clementine (her main bot DM, owner
+                // channel, dashboard, or CLI) and hasn't locked the session to a
+                // specific agent profile, classify whether the message should go
+                // to a specialist. Direct-to-agent-bot sessions bypass this entirely.
+                // Small-talk and meta queries stay with Clementine by default.
+                const routingResult = !isInternalMsg && !sess?.profile && !text.startsWith('!')
+                    ? await this._maybeRouteToSpecialist(sessionKey, text, onText)
+                    : null;
+                if (routingResult?.delegated) {
+                    return routingResult.ackMessage;
+                }
+                // Soft-suggest mode: pass annotation through to Clementine's reply
+                if (routingResult?.softSuggest) {
+                    securityAnnotation = (securityAnnotation
+                        ? securityAnnotation + '\n\n'
+                        : '') + routingResult.softSuggest;
+                }
+                // ── Pre-flight planning for complex asks ───────────────────────
+                // For interactive sessions only (owner DMs, dashboard, CLI), a
+                // cheap deterministic heuristic flags complex multi-step requests.
+                // When it fires, we prepend a directive to the text that tells
+                // the agent to propose a plan + stop, rather than executing
+                // directly. Not a hard stop — on the user's "go" reply the
+                // agent proceeds from the plan it proposed.
+                let enrichedText = text;
+                const isInteractive = isOwnerDm
+                    || sessionKey.startsWith('dashboard:')
+                    || sessionKey.startsWith('cli:');
+                if (isInteractive && !isInternalMsg && !text.startsWith('!')) {
+                    try {
+                        const { classifyComplexity, planFirstDirective } = await import('../agent/complexity-classifier.js');
+                        const verdict = classifyComplexity(text);
+                        if (verdict.complex) {
+                            logger.info({ sessionKey, signals: verdict.signals, reason: verdict.reason }, 'Pre-flight planning directive injected');
+                            enrichedText = `${planFirstDirective()}\n\n---\n\n${text}`;
+                        }
+                    }
+                    catch (err) {
+                        logger.debug({ err }, 'Complexity classifier failed (non-fatal)');
+                    }
+                }
                 // ── Deep mode control ──────────────────────────────────────────
                 if (sess?.deepTask) {
                     const lower = text.toLowerCase().trim();
@@ -796,7 +899,7 @@ export class Gateway {
                 // If the previous query on this session was interrupted by this
                 // incoming message, fold the partial output in so the agent can pivot
                 // smoothly instead of re-planning from scratch.
-                let chatPrompt = text;
+                let chatPrompt = enrichedText;
                 const interrupt = sessState.pendingInterrupt;
                 if (interrupt && interrupt.partial.trim()) {
                     delete sessState.pendingInterrupt;
@@ -804,7 +907,7 @@ export class Gateway {
                     chatPrompt =
                         `[You were mid-response when the user sent a new message — they chose not to wait. ` +
                             `Here's what you had said so far (may be mid-sentence):\n---\n${partialPreview}\n---\n` +
-                            `New message from user:]\n\n${text}`;
+                            `New message from user:]\n\n${enrichedText}`;
                     logger.info({ sessionKey, partialLen: interrupt.partial.length }, 'Folding interrupted partial into new prompt');
                 }
                 else if (interrupt) {
@@ -1380,4 +1483,43 @@ export class Gateway {
         }
     }
 }
+/**
+ * In-memory ring buffer of recent routing decisions. The dashboard
+ * endpoint reads from this without hitting disk. Persisted to
+ * routing-audit.jsonl on every append so a restart replays them from
+ * the file next boot (TODO if we need the history to survive restarts).
+ */
+const _routeAuditBuffer = [];
+function logRouteDecision(opts) {
+    const action = opts.decision.targetAgent === 'clementine'
+        ? 'stayed-with-clementine'
+        : opts.decision.confidence >= 0.8
+            ? 'auto-delegated'
+            : opts.decision.confidence >= 0.5
+                ? 'soft-suggested'
+                : 'stayed-with-clementine';
+    const entry = {
+        timestamp: new Date().toISOString(),
+        sessionKey: opts.sessionKey,
+        messageSnippet: opts.message.slice(0, 300),
+        targetAgent: opts.decision.targetAgent,
+        confidence: opts.decision.confidence,
+        reasoning: opts.decision.reasoning,
+        action,
+    };
+    _routeAuditBuffer.push(entry);
+    while (_routeAuditBuffer.length > 200)
+        _routeAuditBuffer.shift();
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { appendFileSync } = require('node:fs');
+        appendFileSync(Gateway.routeAuditLogPath(), JSON.stringify(entry) + '\n');
+    }
+    catch (err) {
+        logger.debug({ err }, 'Route audit log write failed (non-fatal)');
+    }
+}
+export function getRecentRouteDecisions(limit = 50) {
+    return _routeAuditBuffer.slice(-limit).reverse();
+}
 //# sourceMappingURL=router.js.map

package/dist/memory/store.js

@@ -436,6 +436,17 @@ export class MemoryStore {
       CREATE INDEX IF NOT EXISTS idx_claims_status ON claims(status, extracted_at DESC);
       CREATE INDEX IF NOT EXISTS idx_claims_due ON claims(due_at) WHERE status = 'pending';
       CREATE INDEX IF NOT EXISTS idx_claims_extracted ON claims(extracted_at DESC);
+
+      CREATE TABLE IF NOT EXISTS graded_runs (
+        job_name TEXT NOT NULL,
+        started_at TEXT NOT NULL,
+        passed INTEGER NOT NULL,
+        score INTEGER NOT NULL,
+        reasoning TEXT,
+        graded_at TEXT NOT NULL DEFAULT (datetime('now')),
+        PRIMARY KEY (job_name, started_at)
+      );
+      CREATE INDEX IF NOT EXISTS idx_graded_runs_job ON graded_runs(job_name, started_at DESC);
     `);
     }
     // ── Skill usage telemetry ─────────────────────────────────────────

package/package.json

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