clementine-agent 1.18.48 → 1.18.50

package/dist/agent/agent-definitions.js

@@ -62,18 +62,41 @@ const CRON_FIXER_PROMPT = [
     '',
     'Return: a one-paragraph summary of what you applied (or what is blocking apply), per job.',
 ].join('\n');
+/** Build a routing-signal description for a hired agent.
+ *  The SDK uses descriptions for auto-routing — they must be imperative
+ *  ("Use for: ..."), not narrative prose. Otherwise the main agent
+ *  has nothing to match user phrasings against. */
+function buildHiredAgentDescription(p) {
+    const role = p.role ?? p.description ?? `${p.name}, a hired agent`;
+    const slug = p.slug;
+    const capabilities = (p.routingHints && p.routingHints.length > 0)
+        ? p.routingHints.join(', ')
+        : (p.description ?? '').slice(0, 200);
+    return [
+        `Delegate to ${p.name} (${slug}).`,
+        capabilities ? `Use for: ${capabilities}.` : '',
+        `Role: ${role}.`,
+        'Spawn this subagent when the user names them, asks a question in their domain, or asks Clementine to "have <name> do X".',
+    ].filter(Boolean).join(' ');
+}
 /** Map a hired-agent profile to an AgentDefinition.
  *  Used when Clementine wants to delegate to Ross/Sasha/Nora etc. */
 function profileToAgentDefinition(p) {
+    // Always include `Agent` so the subagent can further fan out, plus
+    // core read tools as a baseline. profile.team.allowedTools narrows
+    // beyond this when set.
+    const baseline = ['Agent', 'Read', 'Grep', 'Glob', 'WebSearch', 'WebFetch', 'TodoWrite'];
+    const tools = p.team?.allowedTools?.length
+        ? Array.from(new Set(['Agent', ...p.team.allowedTools]))
+        : baseline;
     return {
-        description: p.description ?? `${p.name} (hired agent: ${p.slug})`,
+        description: buildHiredAgentDescription(p),
         prompt: p.systemPromptBody ?? `You are ${p.name}.`,
-        // Honor explicit allowlist when present; otherwise inherit from parent.
-        ...(p.team?.allowedTools?.length ? { tools: p.team.allowedTools } : {}),
+        tools,
         // Hired agents keep their configured model (Sonnet by default).
         ...(p.model ? { model: p.model } : { model: 'sonnet' }),
-        // Effort: hired agents do real work, default medium. Caller can override.
-        effort: 'medium',
+        // Effort: hired agents do real work, default medium. Profile may override.
+        ...(p.effort ? { effort: p.effort } : { effort: 'medium' }),
     };
 }
 /**
@@ -89,8 +112,19 @@ export function buildAgentMap(opts = {}) {
     // ── System subagents ────────────────────────────────────────────
     // Planner: opus, no tools, single turn. Used when the parent agent
     // sees a multi-step request and wants a decomposition.
+    // Description is imperative + matches real user phrasings — the SDK
+    // matches against it for auto-routing, so prose doesn't trigger.
     map['planner'] = {
-        description: 'Decompose a multi-step user request into atomic, parallel-safe steps. Use for "research these N items", "build a comprehensive X", "for each Y do Z", or any request that obviously involves multiple distinct sub-tasks. Returns a JSON plan; the parent then executes the steps (often by spawning more subagents per step).',
+        description: [
+            'Use this subagent BEFORE doing the work whenever the user request',
+            'involves 3 or more items, multiple distinct subtasks, or a phrase',
+            'like "research my top N", "for each X do Y", "look at all of",',
+            '"go through every", "do A, B, and C", or any task that would burn',
+            'context if processed serially. The planner returns a JSON plan',
+            'with parallel-safe steps; you then spawn researcher/cron-fixer/',
+            'hired-agent subagents per step. Always prefer this over doing',
+            'multi-item work yourself in the main conversation.',
+        ].join(' '),
         prompt: PLANNER_PROMPT,
         model: 'opus',
         tools: [], // pure reasoning, no tools
@@ -98,11 +132,18 @@ export function buildAgentMap(opts = {}) {
         maxTurns: 1,
     };
     // Researcher: haiku, per-item investigation. Cheap fan-out target.
+    // No Bash — researcher is read-only fanout, must not mutate state.
     map['researcher'] = {
-        description: 'Investigate ONE specific item (one lead, one account, one file, one topic) and return a one-paragraph summary. Use for per-item parallel work spawned by the planner. Cheap and fast.',
+        description: [
+            'Use this subagent to investigate ONE specific item — a single',
+            'lead, account, file, web page, or topic — and return a',
+            'one-paragraph summary. Spawn it in PARALLEL via the Agent tool',
+            'with one subagent per item when the planner returns multiple',
+            'research steps. Read-only: never mutates state. Cheap (Haiku).',
+        ].join(' '),
         prompt: RESEARCHER_PROMPT,
         model: 'haiku',
-        tools: ['Read', 'Grep', 'Glob', 'Bash', 'WebSearch', 'WebFetch'],
+        tools: ['Read', 'Grep', 'Glob', 'WebSearch', 'WebFetch'],
         effort: 'low',
         maxTurns: 15,
     };

package/dist/agent/assistant.d.ts

@@ -9,9 +9,8 @@
  *   - Session expiry: sessions expire after 24 hours of inactivity
  *   - Env isolation: Claude subprocess doesn't see credential env vars
  */
-import type { AgentProfile, OnTextCallback, OnToolActivityCallback, VerboseLevel } from '../types.js';
+import type { AgentProfile } from '../types.js';
 import { AgentManager } from './agent-manager.js';
-import { type ToolsetName } from './toolsets.js';
 /**
  * Estimate token count for Claude.
  *
@@ -28,13 +27,10 @@ import { type ToolsetName } from './toolsets.js';
  * SDK result; this function is for pre-flight planning only.
  */
 export declare function estimateTokens(text: string): number;
-export declare function looksLikeContextThrashText(value: unknown): boolean;
 /** Format a millisecond duration as a human-friendly "X ago" string. */
 export declare function formatTimeAgo(ms: number): string;
-export declare function scrubInternalContextBlocks(text: string): string;
 export declare function looksLikeOneMillionContextError(value: unknown): boolean;
 export declare function oneMillionContextRecoveryMessage(): string;
-export declare function looksLikeProviderApiErrorResponse(value: unknown): boolean;
 export declare function looksLikeNoResponseRequested(value: unknown): boolean;
 /** Autonomous jobs use this sentinel to mean "completed, but do not notify the owner." */
 export declare function isAutonomousNothingOutput(response: string): boolean;
@@ -59,13 +55,6 @@ export interface ProactiveGoalInput {
         nextActions?: string[];
     };
 }
-/**
- * Build the compact "active goals" block that gets injected when no goal
- * keyword matches the user's prompt. Pure so it can be tested without the
- * full Assistant/vault setup.
- */
-export declare function buildActiveGoalsBlock(goals: ProactiveGoalInput[], agentSlug?: string | null, maxEntries?: number): string;
-export declare function chunkReferencedInResponse(chunkContent: string, responseLower: string): boolean;
 export declare class PersonalAssistant {
     static readonly MAX_SESSION_EXCHANGES = 40;
     private sessions;
@@ -80,9 +69,6 @@ export declare class PersonalAssistant {
     private _lastDailyNotePath;
     private memoryStore;
     private _lastUserMessage?;
-    private onUnleashedComplete;
-    private onPhaseComplete;
-    private onPhaseProgress;
     onSkillProposed: ((skill: import('../types.js').SkillDocument) => void) | null;
     private _lastMcpStatus;
     private _lastMcpStatusTime;
@@ -91,8 +77,6 @@ export declare class PersonalAssistant {
     /** Per-session stall nudge — set after a query shows stall signals, consumed on the next query. */
     private stallNudges;
     /** Last contradiction finding per session, consumed by the session transcript writer to splice a correction note. */
-    private _lastContradictionFinding;
-    private _compactedSessions;
     /** Last auto-matched project per session — exposed for CLI display. */
     private _lastMatchedProject;
     /**
@@ -100,7 +84,6 @@ export declare class PersonalAssistant {
      * post-response outcome scorer can check which actually got referenced.
      * Cleared after each scoring pass.
      */
-    private _lastRetrievedChunks;
     /** Lazy-built SessionStore adapter that mirrors SDK transcripts to SQLite. */
     private _sessionStore;
     /** Hot correction buffer — explicit behavioral corrections applied before nightly SI. */
@@ -109,11 +92,6 @@ export declare class PersonalAssistant {
     private initPromptWatchers;
     /** Log SDK result metrics and store usage. Shared across all query methods. */
     private logQueryResult;
-    /** Capture MCP server status from system init messages. */
-    private captureMcpStatus;
-    setUnleashedCompleteCallback(cb: (jobName: string, result: string) => void): void;
-    setPhaseCompleteCallback(cb: (jobName: string, phase: number, totalPhases: number, output: string) => void): void;
-    setPhaseProgressCallback(cb: (jobName: string, phase: number, summary: string) => void): void;
     setSkillProposedCallback(cb: (skill: import('../types.js').SkillDocument) => void): void;
     getMcpStatus(): {
         servers: Array<{
@@ -153,45 +131,6 @@ export declare class PersonalAssistant {
     getMemoryChunkCount(): number;
     private buildSystemPrompt;
     private buildOptions;
-    private retrieveContext;
-    /** Cached active goals — avoids N file reads per query. Refreshes every 30s. */
-    private _goalCache;
-    private static readonly GOAL_CACHE_TTL_MS;
-    private loadGoalsFromCache;
-    /**
-     * Match a user message against active goals by keyword overlap.
-     * Returns formatted goal status block for injection into system prompt,
-     * or empty string if no goals match.
-     */
-    private matchGoals;
-    /**
-     * Compact always-on block of active goals. Used when no keyword match
-     * fires so the agent still sees what it's supposed to be working on.
-     * Scoped: for agent sessions, includes that agent's goals plus any
-     * clementine-owned goals it might contribute to.
-     */
-    private formatActiveGoalsBlock;
-    chat(text: string, sessionKey?: string | null, options?: {
-        onText?: OnTextCallback;
-        onToolActivity?: OnToolActivityCallback;
-        model?: string;
-        maxTurns?: number;
-        profile?: AgentProfile;
-        securityAnnotation?: string;
-        projectOverride?: ProjectMeta;
-        verboseLevel?: VerboseLevel;
-        abortController?: AbortController;
-        toolset?: ToolsetName;
-    }): Promise<[string, string]>;
-    /**
-     * Compare retrieved chunks against the response text and record which
-     * were referenced. Uses a distinctive-token overlap heuristic — cheap,
-     * deterministic, no extra LLM calls. Called right after a turn completes.
-     */
-    private scoreRetrievalOutcomes;
-    private static readonly RATE_LIMIT_MAX_RETRIES;
-    private static readonly RATE_LIMIT_BACKOFF;
-    private runQuery;
     /**
      * Compact a session's context when nearing the context window limit.
      *
@@ -208,11 +147,6 @@ export declare class PersonalAssistant {
         summary?: string;
         reason: string;
     };
-    /**
-     * Expire sessions inactive for more than 24 hours.
-     * Called periodically from chat() to prevent unbounded map growth.
-     */
-    private expireOldSessions;
     /**
      * Build an instant local summary from in-memory exchange history.
      * No LLM call — returns immediately. Used during session rotation
@@ -227,36 +161,10 @@ export declare class PersonalAssistant {
      * (which represent in-flight messages with no reply yet).
      */
     private pairTranscriptTurns;
-    /**
-     * Build a short summary of older turns (older than what's already cached
-     * in `lastExchanges`) for restart-restore prompt injection. Returns ''
-     * if there's nothing older or no memory store. Capped at 600 chars.
-     */
-    private buildOlderTurnsContext;
-    /**
-     * Reconstruct context after the SDK reports the session is dead
-     * ("no conversation found"). Pulls last N turns from the transcripts
-     * table (hydrating `lastExchanges` if the cache is too thin) and
-     * builds a recovery prefix that gets prepended to the retry prompt.
-     * Mirrors the buildContextRecoveredPrompt pattern used by autocompact.
-     */
-    private buildSessionDeathRecoveryPrompt;
-    /**
-     * Auto-save a lightweight handoff file when a session rotates.
-     * Uses in-memory exchange history — no LLM call.
-     */
-    private saveAutoHandoff;
-    /**
-     * Load a handoff file for a session if one exists.
-     * Returns formatted context string or empty string.
-     */
-    private loadHandoff;
     /**
      * Run an LLM summary in the background and save to memoryStore.
      * Does not block the caller — for future retrieval context only.
      */
-    private summarizeSessionAsync;
-    private summarizeSession;
     /**
      * Parse a structured checkpoint from an unleashed phase's STATUS SUMMARY output.
      * Returns null if no recognizable structure is found.
@@ -270,10 +178,6 @@ export declare class PersonalAssistant {
     } | null;
     /** Fire-and-forget: extract a reusable skill from a successful execution. */
     private extractSkillFromExecution;
-    private preRotationFlush;
-    private lastExtractionTimes;
-    private memoryExtractionKey;
-    private assessMemoryExtraction;
     private logMemoryExtractionSkip;
     /**
      * Public entry point for triggering auto-memory extraction after an
@@ -298,7 +202,6 @@ export declare class PersonalAssistant {
     private spawnMemoryExtraction;
     private static readonly MEMORY_TOOL_NAMES;
     private extractMemory;
-    heartbeat(standingInstructions: string, changesSummary?: string, timeContext?: string, dedupContext?: string, profile?: AgentProfile | null): Promise<string>;
     runPlanStep(stepId: string, prompt: string, opts?: {
         tier?: number;
         maxTurns?: number;
@@ -315,9 +218,6 @@ export declare class PersonalAssistant {
         usageLabel?: string;
         usageAgentSlug?: string;
     }): Promise<string>;
-    runCronJob(jobName: string, jobPrompt: string, tier?: number, maxTurns?: number, model?: string, workDir?: string, timeoutMs?: number, successCriteria?: string[], agentSlug?: string, opts?: {
-        disableAllTools?: boolean;
-    }): Promise<string>;
     /**
      * Goal-backward verification pass using Haiku after cron job execution.
      * Instead of vague quality ratings, verifies actual outcomes:
@@ -326,15 +226,6 @@ export declare class PersonalAssistant {
      * 3. Does it connect to the goal / produce actionable results? (wired)
      */
     private runCronReflection;
-    runUnleashedTask(jobName: string, jobPrompt: string, tier?: number, maxTurns?: number, model?: string, workDir?: string, maxHours?: number, agentSlug?: string): Promise<string>;
-    /**
-     * Run a team message as an unleashed-style autonomous task.
-     * Gives team agents the same multi-phase execution as cron jobs,
-     * instead of being killed by the 5-minute interactive chat timeout.
-     *
-     * @param onText  Streaming callback for real-time progress updates
-     */
-    runTeamTask(fromName: string, fromSlug: string, content: string, profile: AgentProfile, onText?: (token: string) => void, externalAbortController?: AbortController): Promise<string>;
     /**
      * Inject a user/assistant exchange into a session's context without running
      * a query.  Used to give the DM session visibility of cron/heartbeat outputs