clementine-agent 1.18.0 → 1.18.2

package/dist/agent/assistant.d.ts

@@ -267,6 +267,7 @@ export declare class PersonalAssistant {
             schema: Record<string, unknown>;
         };
         delegateProfile?: AgentProfile;
+        abortSignal?: AbortSignal;
     }): Promise<string>;
     runCronJob(jobName: string, jobPrompt: string, tier?: number, maxTurns?: number, model?: string, workDir?: string, timeoutMs?: number, successCriteria?: string[], agentSlug?: string, opts?: {
         disableAllTools?: boolean;

package/dist/agent/assistant.js

@@ -1578,11 +1578,17 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
         // every turn regardless.
         if (!isAutonomous) {
             try {
-                const { loadToolPreferences, computeAvailability, buildPromptInstruction } = require('../integrations/tool-preferences.js');
+                const { loadToolPreferences, computeAvailability, buildPromptInstruction, buildComposioStatusBlock } = require('../integrations/tool-preferences.js');
                 const { loadClaudeIntegrations } = require('./mcp-bridge.js');
                 const composioSet = new Set(composioConnectedSlugs);
                 const cdIntegrations = loadClaudeIntegrations();
                 const cdActive = new Set(Object.values(cdIntegrations).filter(i => i.connected).map(i => i.name));
+                // Status block first — gives the model ground truth that Composio
+                // is configured and which toolkits are live, so it stops guessing
+                // whether `mcp__<slug>__*` tools are Composio or something else.
+                const statusBlock = buildComposioStatusBlock(composioConnectedSlugs);
+                if (statusBlock)
+                    volatileParts.push(statusBlock);
                 const prefs = loadToolPreferences();
                 const availability = computeAvailability(composioSet, cdActive, prefs.preferences);
                 const instruction = buildPromptInstruction(availability, prefs.preferences);
@@ -4069,10 +4075,19 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
     }
     // ── Plan Step Execution ───────────────────────────────────────────
     async runPlanStep(stepId, prompt, opts = {}) {
-        const { tier = 2, maxTurns = 15, model, disableTools = false, outputFormat, delegateProfile } = opts;
+        const { tier = 2, maxTurns = 15, model, disableTools = false, outputFormat, delegateProfile, abortSignal } = opts;
         // Don't mutate the global — pass source through the closure instead
         // Per-step stall guard so concurrent steps don't cross-contaminate
         const stepGuard = new StallGuard();
+        // Per-step AbortController, mirroring the parent signal so the orchestrator
+        // (or gateway, via the session AC) can stop in-flight SDK streams.
+        const stepAc = new AbortController();
+        if (abortSignal) {
+            if (abortSignal.aborted)
+                stepAc.abort(abortSignal.reason);
+            else
+                abortSignal.addEventListener('abort', () => stepAc.abort(abortSignal.reason), { once: true });
+        }
         const sdkOptions = await this.buildOptions({
             isHeartbeat: false,
             cronTier: tier,
@@ -4085,6 +4100,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
             outputFormat,
             stallGuard: stepGuard,
             profile: delegateProfile ?? null,
+            abortController: stepAc,
         });
         const trace = [];
         const stream = query({ prompt, options: sdkOptions });

package/dist/agent/orchestrator.d.ts

@@ -39,6 +39,7 @@ export declare class PlanOrchestrator {
     private startTime;
     private stateId;
     private agentProfiles;
+    private abortSignal?;
     constructor(assistant: PersonalAssistant);
     /** Fire-and-forget autonomy telemetry — must never throw. */
     private logAutonomy;
@@ -48,8 +49,12 @@ export declare class PlanOrchestrator {
     static loadState(stateId: string): PlanState | null;
     /**
      * Main entry: plan → approve → execute → synthesize → return final response.
+     *
+     * `abortSignal` (typically the gateway session controller) lets the user stop
+     * a running plan: the orchestrator checks it between waves and forwards it to
+     * every `runPlanStep` call so in-flight SDK streams abort immediately.
      */
-    run(taskDescription: string, onProgress?: (updates: PlanProgressUpdate[]) => Promise<void>, onApproval?: (planSummary: string, steps: PlanStep[]) => Promise<boolean | string>, availableAgents?: AgentProfile[]): Promise<string>;
+    run(taskDescription: string, onProgress?: (updates: PlanProgressUpdate[]) => Promise<void>, onApproval?: (planSummary: string, steps: PlanStep[]) => Promise<boolean | string>, availableAgents?: AgentProfile[], abortSignal?: AbortSignal): Promise<string>;
     /**
      * Goal-backward verification pass using Haiku after plan synthesis.
      * Verifies outcomes rather than just rating quality:

package/dist/agent/orchestrator.js

@@ -123,6 +123,7 @@ export class PlanOrchestrator {
     startTime = 0;
     stateId;
     agentProfiles = new Map();
+    abortSignal;
     constructor(assistant) {
         this.assistant = assistant;
         this.stateId = `plan-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
@@ -172,13 +173,18 @@ export class PlanOrchestrator {
     }
     /**
      * Main entry: plan → approve → execute → synthesize → return final response.
+     *
+     * `abortSignal` (typically the gateway session controller) lets the user stop
+     * a running plan: the orchestrator checks it between waves and forwards it to
+     * every `runPlanStep` call so in-flight SDK streams abort immediately.
      */
-    async run(taskDescription, onProgress, onApproval, availableAgents) {
+    async run(taskDescription, onProgress, onApproval, availableAgents, abortSignal) {
         // Reset instance state for reuse safety
         this.stepStatuses.clear();
         this.stepStartTimes.clear();
         this.agentProfiles.clear();
         this.startTime = Date.now();
+        this.abortSignal = abortSignal;
         // Index available agents for delegation lookups
         if (availableAgents) {
             for (const agent of availableAgents) {
@@ -281,6 +287,15 @@ export class PlanOrchestrator {
         };
         this.saveState(state);
         for (const wave of waves) {
+            // User-initiated cancellation: bail before starting the next wave so we
+            // don't kick off SDK streams the user already asked to stop.
+            if (this.abortSignal?.aborted) {
+                logger.info({ goal: taskDescription, wavesCompleted: state.wavesCompleted }, 'Plan cancelled by user');
+                state.status = 'failed';
+                this.saveState(state);
+                this.logAutonomy('plan_aborted', { reason: 'user_cancelled', wavesCompleted: state.wavesCompleted });
+                return 'Plan cancelled.';
+            }
             // Mark running
             for (const step of wave) {
                 this.stepStatuses.set(step.id, {
@@ -303,6 +318,7 @@ export class PlanOrchestrator {
                     maxTurns: step.maxTurns ?? 15,
                     model: step.model,
                     delegateProfile,
+                    abortSignal: this.abortSignal,
                 });
                 return { stepId: step.id, result };
             }), MAX_CONCURRENT_STEPS);
@@ -341,6 +357,16 @@ export class PlanOrchestrator {
                 }
             }
             await safeProgress(this.getAllUpdates());
+            // If the user aborted mid-wave, the SDK calls above already threw and
+            // `outcome.reason` will reflect the abort. Surface that as a clean
+            // cancellation instead of falling through to spot-check / repair / synthesis.
+            if (this.abortSignal?.aborted) {
+                logger.info({ goal: taskDescription, wavesCompleted: state.wavesCompleted }, 'Plan cancelled by user mid-wave');
+                state.status = 'failed';
+                this.saveState(state);
+                this.logAutonomy('plan_aborted', { reason: 'user_cancelled', wavesCompleted: state.wavesCompleted });
+                return 'Plan cancelled.';
+            }
             // Inter-wave spot-check with severity levels: critical issues trigger repair
             const spotCheckIssues = this.spotCheckWaveResults(wave, results);
             if (spotCheckIssues.length > 0) {
@@ -362,6 +388,7 @@ export class PlanOrchestrator {
                                         tier: step.tier ?? 2,
                                         maxTurns: step.maxTurns ?? 15,
                                         model: step.model,
+                                        abortSignal: this.abortSignal,
                                     });
                                     results.set(step.id, retryResult || '[No output on retry]');
                                     this.stepStatuses.set(step.id, {
@@ -449,6 +476,7 @@ export class PlanOrchestrator {
                 tier: 2,
                 maxTurns: 5,
                 disableTools: true,
+                abortSignal: this.abortSignal,
             });
         }
         catch (err) {
@@ -619,6 +647,7 @@ export class PlanOrchestrator {
                 maxTurns: 1,
                 model: 'haiku',
                 disableTools: true,
+                abortSignal: this.abortSignal,
             });
             const cleaned = decision.trim().toLowerCase();
             if (cleaned.includes('retry'))
@@ -645,7 +674,7 @@ export class PlanOrchestrator {
                 `If a step matches an agent's specialty, add "delegateTo": "agent-slug" to that step. ` +
                 `The delegated agent will run the step with their own personality, tools, and expertise.\n`;
         }
-        const plannerResult = await this.assistant.runPlanStep('planner', PLANNER_PROMPT + agentContext + task + PLANNER_PROMPT_SUFFIX, { tier: 2, maxTurns: 1, model: 'sonnet', disableTools: true });
+        const plannerResult = await this.assistant.runPlanStep('planner', PLANNER_PROMPT + agentContext + task + PLANNER_PROMPT_SUFFIX, { tier: 2, maxTurns: 1, model: 'sonnet', disableTools: true, abortSignal: this.abortSignal });
         // Parse JSON from the planner response
         const parsed = this.parseJsonFromResponse(plannerResult);
         if (!parsed?.steps || !Array.isArray(parsed.steps) || parsed.steps.length === 0) {
@@ -798,6 +827,7 @@ Work through this task narrating your reasoning:
         return this.assistant.runPlanStep('fallback', task, {
             tier: 2,
             maxTurns: 25,
+            abortSignal: this.abortSignal,
         });
     }
     getAllUpdates() {

package/dist/gateway/router.js

@@ -1424,9 +1424,15 @@ export class Gateway {
                 }
                 // Register provenance for the orchestrator session
                 this.ensureProvenance(sessionKey);
+                // Register a session AbortController so a follow-up message ("stop", or
+                // any new prompt) can interrupt the plan via acquireSessionLock — which
+                // calls abortController.abort('interrupted-by-new-message') when it
+                // sees an in-flight query on this session.
+                const planAc = new AbortController();
+                this.getSession(sessionKey).abortController = planAc;
                 const { PlanOrchestrator } = await import('../agent/orchestrator.js');
                 const orchestrator = new PlanOrchestrator(this.assistant);
-                const result = await orchestrator.run(taskDescription, onProgress, onApproval);
+                const result = await orchestrator.run(taskDescription, onProgress, onApproval, undefined, planAc.signal);
                 scanner.refreshIntegrity();
                 this.assistant.injectContext(sessionKey, `[Plan: ${taskDescription}]`, result);
                 return result;

package/dist/integrations/tool-preferences.d.ts

@@ -68,4 +68,14 @@ export declare function computeAvailability(composioConnectedSlugs: Set<string>,
  *   Compare to the previous always-on hardcoded block which was ~700 chars.
  */
 export declare function buildPromptInstruction(availability: ServiceAvailability[], preferences: Record<string, ToolSource>): string;
+/**
+ * Ground-truth header naming the Composio toolkits currently connected.
+ * Without this, the model has to guess what `mcp__<slug>__*` tools are
+ * (often misattributing them to claude.ai integrations or "extensions"),
+ * because Composio's slug-prefixed naming is ambiguous in isolation.
+ *
+ * Emits an empty string when no toolkits are connected — zero overhead
+ * for users who haven't set up Composio.
+ */
+export declare function buildComposioStatusBlock(connectedSlugs: string[]): string;
 //# sourceMappingURL=tool-preferences.d.ts.map

package/dist/integrations/tool-preferences.js

@@ -116,4 +116,20 @@ export function buildPromptInstruction(availability, preferences) {
         return '';
     return `## Tool Source Preferences\n\nThese rules OVERRIDE any tool-source preference you may recall from memory. Do not consult memory for this — the canonical source is the dashboard's Tool Source Preferences (Settings → Integrations).\n\n${lines.join('\n')}`;
 }
+/**
+ * Ground-truth header naming the Composio toolkits currently connected.
+ * Without this, the model has to guess what `mcp__<slug>__*` tools are
+ * (often misattributing them to claude.ai integrations or "extensions"),
+ * because Composio's slug-prefixed naming is ambiguous in isolation.
+ *
+ * Emits an empty string when no toolkits are connected — zero overhead
+ * for users who haven't set up Composio.
+ */
+export function buildComposioStatusBlock(connectedSlugs) {
+    if (!connectedSlugs.length)
+        return '';
+    const sorted = [...connectedSlugs].sort();
+    const example = sorted[0];
+    return `## Composio Integration\n\nComposio is configured. Connected toolkits: ${sorted.join(', ')}.\n\nTools from these toolkits are namespaced as \`mcp__<slug>__<TOOL_NAME>\` (e.g., \`mcp__${example}__*\`). These are local Composio MCP servers, NOT claude.ai integrations (which use \`mcp__claude_ai_*\`).`;
+}
 //# sourceMappingURL=tool-preferences.js.map

package/package.json

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