clementine-agent 1.18.49 → 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

@@ -27,13 +27,10 @@ import { AgentManager } from './agent-manager.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;
@@ -58,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;

package/dist/agent/assistant.js

@@ -169,10 +169,6 @@ export function estimateTokens(text) {
         return 0;
     return Math.ceil(text.length / 3.3);
 }
-export function looksLikeContextThrashText(value) {
-    const text = String(value ?? '');
-    return /autocompact\s+is\s+thrashing|context\s+refilled\s+to\s+the\s+limit|refilled\s+to\s+the\s+limit\s+within/i.test(text);
-}
 /**
  * Strip lone Unicode surrogates (U+D800–U+DFFF) from a string so it can be
  * safely serialized to JSON. Lone surrogates are valid in JS strings but
@@ -233,25 +229,12 @@ export function formatTimeAgo(ms) {
 function capContextBlock(text, maxChars) {
     return capOutput(String(text ?? ''), maxChars);
 }
-export function scrubInternalContextBlocks(text) {
-    return text
-        .replace(/\[Context governance:[^\]]*\][\s\S]*?\[\/Context governance:[^\]]*\]\s*/gi, '')
-        .replace(/\[Active working set\][\s\S]*?\[\/Active working set\]\s*/gi, '')
-        .replace(/\[Recent proactive notification context\][\s\S]*?\[\/Recent proactive notification context\]\s*/gi, '')
-        .trim();
-}
 export function looksLikeOneMillionContextError(value) {
     return looksLikeClaudeOneMillionContextError(value);
 }
 export function oneMillionContextRecoveryMessage() {
     return "Claude rejected 1M context for this account. I've switched Clementine to persistent 200K recovery mode and reset the session. Restart Clementine once so every background worker starts with the same safe setting.";
 }
-export function looksLikeProviderApiErrorResponse(value) {
-    const text = String(value ?? '').trim();
-    return /^api error:/i.test(text)
-        || /^error:\s*api error:/i.test(text)
-        || looksLikeOneMillionContextError(text);
-}
 export function looksLikeNoResponseRequested(value) {
     const text = String(value ?? '').trim();
     return /^no response requested\.?$/i.test(text);
@@ -711,72 +694,6 @@ export function removeProject(projectPath) {
     _projectsMetaCacheTime = 0; // invalidate cache
     return true;
 }
-// ── Retrieval Outcome Heuristic ─────────────────────────────────────
-/**
- * Decide whether a retrieved memory chunk shows up in the assistant's
- * response. We key on distinctive tokens (multi-letter capitalized words,
- * numbers of 2+ digits) that are unlikely to appear in the response unless
- * the chunk's content actually influenced what was said.
- *
- * Intentionally a cheap local heuristic — no LLM call. False positives are
- * tolerable since the outcome score is bounded and averaged over many
- * observations.
- */
-const OUTCOME_STOPWORDS = new Set([
-    'there', 'these', 'those', 'their', 'where', 'which', 'while',
-    'would', 'could', 'should', 'about', 'being', 'after', 'before',
-    'again', 'against', 'because',
-]);
-/**
- * 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 function buildActiveGoalsBlock(goals, agentSlug, maxEntries = 6) {
-    if (goals.length === 0)
-        return '';
-    const filtered = goals.filter(({ goal }) => {
-        if (!agentSlug)
-            return true;
-        return goal.owner === agentSlug || goal.owner === 'clementine';
-    });
-    if (filtered.length === 0)
-        return '';
-    const rank = { high: 0, medium: 1, low: 2 };
-    const sorted = [...filtered].sort((a, b) => {
-        const ra = rank[a.goal.priority ?? 'medium'] ?? 1;
-        const rb = rank[b.goal.priority ?? 'medium'] ?? 1;
-        return ra - rb;
-    });
-    const top = sorted.slice(0, maxEntries);
-    const lines = top.map(({ goal }) => {
-        const next = goal.nextActions?.[0];
-        const nextBit = next ? ` → ${String(next).slice(0, 80)}` : '';
-        return `- [${goal.priority ?? 'medium'}] ${goal.title}${nextBit}`;
-    });
-    return `\n\n## Active Goals (background context)\n${lines.join('\n')}\n`;
-}
-export function chunkReferencedInResponse(chunkContent, responseLower) {
-    if (!chunkContent || !responseLower)
-        return false;
-    const distinctive = new Set();
-    const capMatches = chunkContent.match(/\b[A-Z][a-zA-Z]{3,}\b/g) ?? [];
-    for (const m of capMatches) {
-        const lower = m.toLowerCase();
-        if (!OUTCOME_STOPWORDS.has(lower))
-            distinctive.add(lower);
-    }
-    const numMatches = chunkContent.match(/\b\d{2,}\b/g) ?? [];
-    for (const m of numMatches)
-        distinctive.add(m);
-    if (distinctive.size === 0)
-        return false;
-    for (const tok of distinctive) {
-        if (responseLower.includes(tok))
-            return true;
-    }
-    return false;
-}
 // ── PersonalAssistant ───────────────────────────────────────────────
 export class PersonalAssistant {
     static MAX_SESSION_EXCHANGES = MAX_SESSION_EXCHANGES;

package/dist/agent/route-classifier.js

@@ -347,12 +347,11 @@ export async function classifyRoute(userMessage, agents, gateway) {
         3, // maxTurns — classifier doesn't need tools
         'haiku', // cheap
         undefined, // workDir
-        'standard', // mode
+        'standard', // mode (display only)
         undefined, // maxHours
         undefined, // timeoutMs
         undefined, // successCriteria
-        undefined, // agentSlug
-        { disableAllTools: true });
+        undefined);
     }
     catch (err) {
         logger.warn({ err }, 'Route classifier call failed');

package/dist/agent/run-agent-context.d.ts

@@ -0,0 +1,17 @@
+import type { AgentProfile } from '../types.js';
+export interface BuildChatContextOptions {
+    /** Active hired-agent profile, when set. The agent-specific MEMORY.md
+     *  in `agents/<slug>/MEMORY.md` is preferred over the global one. */
+    profile?: AgentProfile | null;
+    /** Optional caller-supplied systemPromptBody to append after the
+     *  vault context block (used by hired-agent profiles). */
+    profileAppend?: string;
+}
+/**
+ * Build the system-prompt append string for chat invocations.
+ *
+ * Returns an empty string when none of the source files exist — the
+ * SDK then runs with just the bare `claude_code` preset.
+ */
+export declare function buildChatSystemAppend(opts?: BuildChatContextOptions): string;
+//# sourceMappingURL=run-agent-context.d.ts.map

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

@@ -0,0 +1,80 @@
+/**
+ * Build the vault context block that gets appended to the SDK's
+ * `claude_code` system prompt preset for chat sessions.
+ *
+ * The legacy chat path (`assistant.ts:buildSystemPrompt`) injected
+ * SOUL.md (personality), MEMORY.md (long-term memory), AGENTS.md
+ * (team awareness), and the agent-specific working-memory file. Without
+ * those, the canonical chat path loses the personality, preferences,
+ * and team-roster knowledge that distinguish Clementine from a generic
+ * SDK agent.
+ *
+ * Canonical pattern: SDK accepts `systemPrompt: { type: 'preset',
+ * preset: 'claude_code', append: <string> }`. We append a single
+ * concatenated context block — no wrappers, no recursive prompts.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { SOUL_FILE, AGENTS_FILE, MEMORY_FILE, AGENTS_DIR } from '../config.js';
+const SOUL_MAX_CHARS = 6_000;
+const MEMORY_MAX_CHARS = 8_000;
+const AGENTS_MAX_CHARS = 4_000;
+const PROFILE_MEMORY_MAX_CHARS = 6_000;
+function readFileSafe(p) {
+    try {
+        return fs.existsSync(p) ? fs.readFileSync(p, 'utf-8') : '';
+    }
+    catch {
+        return '';
+    }
+}
+function trimTo(text, max) {
+    if (!text)
+        return '';
+    return text.length <= max ? text : text.slice(0, max - 3) + '...';
+}
+/**
+ * Build the system-prompt append string for chat invocations.
+ *
+ * Returns an empty string when none of the source files exist — the
+ * SDK then runs with just the bare `claude_code` preset.
+ */
+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)}`);
+    }
+    // 2. Long-term memory — agent-specific file overrides the global one.
+    const profileMemoryPath = opts.profile?.slug
+        ? path.join(AGENTS_DIR, opts.profile.slug, 'MEMORY.md')
+        : null;
+    let memory = '';
+    if (profileMemoryPath && fs.existsSync(profileMemoryPath)) {
+        memory = readFileSafe(profileMemoryPath);
+        if (memory.trim()) {
+            blocks.push(`## Long-Term Memory (${opts.profile?.name ?? opts.profile?.slug})\n${trimTo(memory, PROFILE_MEMORY_MAX_CHARS)}`);
+        }
+    }
+    else {
+        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) {
+        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).
+    if (opts.profileAppend?.trim()) {
+        blocks.push(opts.profileAppend);
+    }
+    return blocks.join('\n\n');
+}
+//# sourceMappingURL=run-agent-context.js.map

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

@@ -301,12 +301,23 @@ export async function runAgentCron(opts) {
         abortSignal: opts.abortSignal,
         extraMcpServers: mcp.servers,
     });
+    // Mirror the run into transcripts so future chat recall can see it.
+    // Legacy runCronJob did this with role='cron'; canonical needs the
+    // same so memory queries (`what did Sasha do this morning?`) work.
+    const deliverable = result.text ?? '';
+    if (opts.memoryStore && deliverable.trim()) {
+        try {
+            opts.memoryStore.saveTurn(`cron:${opts.jobName}`, 'cron', deliverable, opts.model ?? '');
+        }
+        catch (err) {
+            logger.debug({ err, job: opts.jobName }, 'runAgentCron: transcript mirror failed (non-fatal)');
+        }
+    }
     // ── Post-task hooks: reflection + skill extraction ────────────────
     // Both fire-and-forget — never block the cron deliverable on these.
     // They are the same passes the legacy runCronJob fires; without them
     // the new path would lose the success-grading + procedural-memory
     // growth that makes Clementine self-improving.
-    const deliverable = result.text ?? '';
     if (opts.postTaskHooks && deliverable && deliverable.trim() !== '__NOTHING__') {
         const durationMs = Date.now() - startedAt;
         opts.postTaskHooks

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

@@ -65,8 +65,9 @@ export async function runAgentHeartbeat(opts) {
         profile: opts.profile?.slug,
         promptChars: prompt.length,
     }, 'runAgentHeartbeat: dispatching to runAgent (no tools)');
-    return runAgent(prompt, {
-        sessionKey: `heartbeat:${opts.profile?.slug ?? 'clementine'}`,
+    const sessionKey = `heartbeat:${opts.profile?.slug ?? 'clementine'}`;
+    const result = await runAgent(prompt, {
+        sessionKey,
         source: 'heartbeat',
         profile: opts.profile,
         memoryStore: opts.memoryStore,
@@ -80,5 +81,17 @@ export async function runAgentHeartbeat(opts) {
         allowedTools: [],
         abortSignal: opts.abortSignal,
     });
+    // Mirror the heartbeat into transcripts so dedup + recall work.
+    // Skip pure __NOTHING__ outputs since they carry no information.
+    const text = result.text?.trim() ?? '';
+    if (opts.memoryStore && text && text !== '__NOTHING__') {
+        try {
+            opts.memoryStore.saveTurn(sessionKey, 'heartbeat', text, opts.model ?? MODELS.haiku);
+        }
+        catch {
+            /* non-fatal */
+        }
+    }
+    return result;
 }
 //# sourceMappingURL=run-agent-heartbeat.js.map

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

@@ -49,8 +49,9 @@ export async function runAgentTeamTask(opts) {
         droppedComposio: mcp.droppedComposio,
         promptChars: builtPrompt.length,
     }, 'runAgentTeamTask: dispatching to runAgent');
+    const sessionKey = `team-task:${opts.fromSlug}->${opts.profile.slug}`;
     const result = await runAgent(builtPrompt, {
-        sessionKey: `team-task:${opts.fromSlug}->${opts.profile.slug}`,
+        sessionKey,
         source: 'team-task',
         profile: opts.profile,
         agentManager: opts.agentManager,
@@ -62,6 +63,19 @@ export async function runAgentTeamTask(opts) {
         abortSignal: opts.abortSignal,
         extraMcpServers: mcp.servers,
     });
+    // Mirror the inbound message + outbound response into transcripts so
+    // future recall sees who-asked-whom and what got done.
+    if (opts.memoryStore) {
+        try {
+            opts.memoryStore.saveTurn(sessionKey, `team-from:${opts.fromSlug}`, opts.content, '');
+            if (result.text?.trim()) {
+                opts.memoryStore.saveTurn(sessionKey, `team-to:${opts.profile.slug}`, result.text, opts.model ?? '');
+            }
+        }
+        catch {
+            /* non-fatal */
+        }
+    }
     return {
         ...result,
         builtPrompt,

package/dist/agent/run-agent.d.ts

@@ -77,6 +77,12 @@ export interface RunAgentOptions {
         url?: string;
         headers?: Record<string, string>;
     }>;
+    /** String appended to the SDK's `claude_code` system-prompt preset.
+     *  Caller-built so chat callers can inject vault context (SOUL.md,
+     *  MEMORY.md, AGENTS.md) while autonomous callers (cron/heartbeat/
+     *  team-task) keep the prompt small. When unset, falls back to
+     *  profile.systemPromptBody (legacy single-source behavior). */
+    systemPromptAppend?: string;
 }
 export interface RunAgentResult {
     /** Final text response from the agent. */

package/dist/agent/run-agent.js

@@ -111,14 +111,28 @@ export async function runAgent(prompt, opts) {
     const effectivePrompt = opts.forceSubagent && agents[opts.forceSubagent]
         ? `Use the ${opts.forceSubagent} agent to handle this request:\n\n${prompt}`
         : prompt;
-    // Compose system prompt. When a hired-agent profile is active, that
-    // becomes the main agent's identity — append to the claude_code preset.
-    const profileAppend = opts.profile?.systemPromptBody
-        ? opts.profile.systemPromptBody
-        : undefined;
-    // Allowed tools. Default to core + Clementine MCP. Per-subagent tool
-    // restrictions live on each AgentDefinition.tools field.
-    const allowedTools = opts.allowedTools ?? CORE_TOOLS_FOR_AGENT_PARENT;
+    // Compose system-prompt append. The caller has already merged any
+    // vault context (SOUL.md, MEMORY.md, AGENTS.md) and profile body
+    // into a single string when needed; otherwise we fall back to the
+    // profile body alone for autonomous paths.
+    const profileAppend = opts.systemPromptAppend?.trim()
+        ? opts.systemPromptAppend
+        : opts.profile?.systemPromptBody?.trim()
+            ? opts.profile.systemPromptBody
+            : undefined;
+    // Allowed tools at the main-agent level.
+    //   1. Caller-provided opts.allowedTools wins (e.g. heartbeat passes []).
+    //   2. When a hired-agent profile is the main agent and it has a
+    //      team.allowedTools allowlist, use it (with `Agent` always
+    //      included so subagent delegation still works).
+    //   3. Otherwise the core set. Per-subagent tool restrictions live
+    //      on each AgentDefinition.tools field, not here.
+    const profileMainAllow = opts.profile?.team?.allowedTools?.length
+        ? Array.from(new Set(['Agent', ...opts.profile.team.allowedTools]))
+        : null;
+    const allowedTools = opts.allowedTools
+        ?? profileMainAllow
+        ?? CORE_TOOLS_FOR_AGENT_PARENT;
     // Wire the Clementine MCP server so the agent can reach memory/cron/
     // broken-job tools. Without this, the cron-fixer subagent's `tools`
     // list references mcp__clementine-tools__* that don't exist in the
@@ -141,6 +155,20 @@ export async function runAgent(prompt, opts) {
         },
         ...(opts.extraMcpServers ?? {}),
     };
+    // Bridge an external AbortSignal to a real AbortController the SDK
+    // can act on. The SDK calls .abort() internally on budget/turn caps,
+    // so we cannot pass a fake { signal } object — it must be a real
+    // controller. When the caller's signal fires we propagate.
+    let sdkAbortController;
+    if (opts.abortSignal) {
+        sdkAbortController = new AbortController();
+        if (opts.abortSignal.aborted) {
+            sdkAbortController.abort();
+        }
+        else {
+            opts.abortSignal.addEventListener('abort', () => sdkAbortController.abort(), { once: true });
+        }
+    }
     // Apply 1M-context env normalization (existing infra)
     const sdkOptionsRaw = {
         systemPrompt: profileAppend
@@ -153,6 +181,10 @@ export async function runAgent(prompt, opts) {
         mcpServers: mcpServers,
         allowedTools,
         permissionMode: 'bypassPermissions',
+        // SDK spec requires this companion flag whenever permissionMode is
+        // 'bypassPermissions'. Without it, autonomous runs can silently
+        // hang waiting for permission prompts.
+        allowDangerouslySkipPermissions: true,
         cwd: BASE_DIR,
         env: subprocessEnv,
         maxBudgetUsd,
@@ -160,7 +192,7 @@ export async function runAgent(prompt, opts) {
         ...(opts.maxTurns ? { maxTurns: opts.maxTurns } : {}),
         ...(opts.model ? { model: opts.model } : {}),
         ...(opts.resumeSessionId ? { resume: opts.resumeSessionId } : {}),
-        ...(opts.abortSignal ? { abortController: { signal: opts.abortSignal } } : {}),
+        ...(sdkAbortController ? { abortController: sdkAbortController } : {}),
     };
     const sdkOptions = normalizeClaudeSdkOptionsForOneMillionContext(sdkOptionsRaw);
     logger.info({

package/dist/gateway/failure-diagnostics.js

@@ -541,7 +541,12 @@ export async function diagnoseBrokenJob(broken, gateway) {
         rawResponse = await gateway.handleCronJob(`diagnose:${broken.jobName}`, prompt, 1, // tier 1 — cheap
         5, // maxTurns — diagnosis doesn't need tools typically
         'haiku', // model — keep cost negligible
-        undefined, 'standard', undefined, undefined, undefined, undefined, { disableAllTools: true });
+        undefined, // workDir
+        'standard', // mode (display only)
+        undefined, // maxHours
+        undefined, // timeoutMs
+        undefined, // successCriteria
+        undefined);
     }
     catch (err) {
         logger.warn({ err, job: broken.jobName }, 'Diagnostic LLM call failed');

package/dist/gateway/heartbeat-scheduler.js

@@ -294,7 +294,12 @@ export class HeartbeatScheduler {
                 // LLM callback for summarization/principle extraction
                 const llmCall = async (prompt) => {
                     const cronCall = buildConsolidationCronCall(prompt);
-                    const result = await this.gateway.handleCronJob(cronCall.jobName, cronCall.jobPrompt, cronCall.tier, cronCall.maxTurns, cronCall.model, undefined, 'standard', undefined, undefined, undefined, undefined, cronCall.opts);
+                    const result = await this.gateway.handleCronJob(cronCall.jobName, cronCall.jobPrompt, cronCall.tier, cronCall.maxTurns, cronCall.model, undefined, // workDir
+                    'standard', // mode (display only)
+                    undefined, // maxHours
+                    undefined, // timeoutMs
+                    undefined, // successCriteria
+                    undefined);
                     return result || '';
                 };
                 const result = await runConsolidation(store, llmCall);
@@ -978,7 +983,12 @@ export class HeartbeatScheduler {
         let response = null;
         try {
             const cronCall = buildInsightCheckCronCall(prompt);
-            response = await this.gateway.handleCronJob(cronCall.jobName, cronCall.jobPrompt, cronCall.tier, cronCall.maxTurns, cronCall.model, undefined, 'standard', undefined, undefined, undefined, undefined, cronCall.opts);
+            response = await this.gateway.handleCronJob(cronCall.jobName, cronCall.jobPrompt, cronCall.tier, cronCall.maxTurns, cronCall.model, undefined, // workDir
+            'standard', // mode (display only)
+            undefined, // maxHours
+            undefined, // timeoutMs
+            undefined, // successCriteria
+            undefined);
             this.runLog.append({
                 jobName: 'insight-check',
                 startedAt: icStartedAt.toISOString(),

package/dist/gateway/outcome-grader.js

@@ -136,12 +136,11 @@ export async function gradeRun(entry, gateway, jobPrompt) {
         raw = await gateway.handleCronJob(`grade:${entry.jobName}`, prompt, 1, // tier 1
         3, // maxTurns — tight
         'haiku', undefined, // workDir
-        'standard', // mode
+        'standard', // mode (display only)
         undefined, // maxHours
         undefined, // timeoutMs
         undefined, // successCriteria
-        undefined, // agentSlug
-        { disableAllTools: true });
+        undefined);
     }
     catch (err) {
         logger.warn({ err, jobName: entry.jobName }, 'Outcome grader LLM call failed');

package/dist/gateway/router.d.ts

@@ -167,9 +167,10 @@ export declare class Gateway {
     handleMessage(sessionKey: string, text: string, onText?: OnTextCallback, model?: string, maxTurns?: number, onToolActivity?: OnToolActivityCallback, onProgress?: OnProgressCallback): Promise<string>;
     private _handleMessageInner;
     handleHeartbeat(standingInstructions: string, changesSummary?: string, timeContext?: string, dedupContext?: string, profile?: import('../types.js').AgentProfile | null): Promise<string>;
-    handleCronJob(jobName: string, jobPrompt: string, tier?: number, maxTurns?: number, model?: string, workDir?: string, _mode?: 'standard' | 'unleashed', _maxHours?: number, _timeoutMs?: number, successCriteria?: string[], agentSlug?: string, _opts?: {
-        disableAllTools?: boolean;
-    }): Promise<string>;
+    handleCronJob(jobName: string, jobPrompt: string, tier?: number, maxTurns?: number, model?: string, workDir?: string, 
+    /** Accepted for back-compat; canonical SDK path executes every job
+     *  identically. Affects only UI display + budget heuristics elsewhere. */
+    _mode?: 'standard' | 'unleashed', maxHours?: number, timeoutMs?: number, successCriteria?: string[], agentSlug?: string): Promise<string>;
     /**
      * Process a team message as an autonomous task — same multi-phase execution
      * as cron unleashed jobs, so agents can work until done instead of being

package/dist/gateway/router.js

@@ -16,7 +16,6 @@ import { lanes } from './lanes.js';
 import { AgentManager } from '../agent/agent-manager.js';
 import { TeamRouter } from '../agent/team-router.js';
 import { TeamBus } from '../agent/team-bus.js';
-import { events } from '../events/bus.js';
 import { listBackgroundTasks, loadBackgroundTask, markFailed } from '../agent/background-tasks.js';
 import { applyAssistantExperienceUpdate, detectApprovalReply, detectLocalTurn } from '../agent/local-turn.js';
 import { buildApprovalFollowupPrompt, detectActionExpectation } from '../agent/action-enforcer.js';
@@ -1497,7 +1496,6 @@ export class Gateway {
                     logger.info({ sessionKey, laneWaitMs }, 'Chat lane wait was non-trivial');
                 }
                 logger.info(`Message from ${sessionKey}: ${text.slice(0, 100)}...`);
-                events.emit('message:received', { sessionKey, text, timestamp: Date.now() });
                 // ── Register provenance on first interaction ────────────────
                 this.ensureProvenance(sessionKey);
                 // ── Pre-flight injection scan ───────────────────────────────
@@ -1780,10 +1778,32 @@ export class Gateway {
                     // runAgent() owns chat. No legacy fallback — errors propagate
                     // to the catch block below for honest classification.
                     const { runAgent } = await import('../agent/run-agent.js');
+                    const { buildExtraMcpForRunAgent } = await import('../agent/run-agent-mcp.js');
+                    const { buildChatSystemAppend } = await import('../agent/run-agent-context.js');
+                    // Wire Composio + external MCP servers (Outlook, Gmail,
+                    // Salesforce, etc) so chat can reach the same tools the
+                    // legacy chat path did. Profile allowlists override the
+                    // bundle router when set.
+                    const chatMcp = await buildExtraMcpForRunAgent({
+                        scopeText: chatPrompt,
+                        profile: resolvedProfile,
+                    });
+                    // Inject vault context (SOUL.md / MEMORY.md / AGENTS.md +
+                    // optional profile body) into the system-prompt append so
+                    // the agent has personality + long-term memory + team
+                    // awareness. Profile-specific MEMORY.md takes precedence
+                    // over the global one when a hired agent is active.
+                    const chatSystemAppend = buildChatSystemAppend({
+                        profile: resolvedProfile,
+                        profileAppend: resolvedProfile?.systemPromptBody,
+                    });
                     logger.info({
                         sessionKey: effectiveSessionKey,
                         profile: resolvedProfile?.slug,
                         path: 'runagent_chat',
+                        composioConnected: chatMcp.composioConnected.length,
+                        externalConnected: chatMcp.externalConnected.length,
+                        systemAppendChars: chatSystemAppend.length,
                     }, 'Routing chat through runAgent');
                     const runAgentResult = await runAgent(chatPrompt, {
                         sessionKey: effectiveSessionKey,
@@ -1793,6 +1813,8 @@ export class Gateway {
                         memoryStore: this.assistant.getMemoryStore?.() ?? null,
                         ...(effectiveModel ? { model: effectiveModel } : {}),
                         ...(maxTurns ? { maxTurns } : {}),
+                        ...(chatSystemAppend ? { systemPromptAppend: chatSystemAppend } : {}),
+                        extraMcpServers: chatMcp.servers,
                         onText: wrappedOnText,
                         onToolActivity: ({ tool, input }) => {
                             toolActivityCount++;
@@ -1888,7 +1910,6 @@ export class Gateway {
                 return '__NOTHING__';
             }
             logger.info({ agent }, 'Running heartbeat...');
-            events.emit('heartbeat:start', { agent, timestamp: Date.now() });
             const hbStart = Date.now();
             try {
                 const { runAgentHeartbeat } = await import('../agent/run-agent-heartbeat.js');
@@ -1902,21 +1923,16 @@ export class Gateway {
                     memoryStore: this.assistant.getMemoryStore?.() ?? null,
                 });
                 scanner.refreshIntegrity();
-                events.emit('heartbeat:complete', {
-                    agent,
-                    durationMs: Date.now() - hbStart,
-                    responseLength: result.text?.length ?? 0,
-                });
                 logger.info({
                     agent,
                     cost: Number(result.totalCostUsd.toFixed(4)),
                     numTurns: result.numTurns,
                     durationMs: Date.now() - hbStart,
+                    responseLen: result.text?.length ?? 0,
                 }, 'runAgentHeartbeat: heartbeat complete');
                 return result.text;
             }
             catch (err) {
-                events.emit('heartbeat:error', { agent, error: String(err) });
                 logger.error({ err }, 'Heartbeat error');
                 return `Heartbeat error: ${err}`;
             }
@@ -1925,18 +1941,34 @@ export class Gateway {
             releaseLane();
         }
     }
-    async handleCronJob(jobName, jobPrompt, tier = 1, maxTurns, model, workDir, _mode = 'standard', _maxHours, _timeoutMs, successCriteria, agentSlug, _opts) {
+    async handleCronJob(jobName, jobPrompt, tier = 1, maxTurns, model, workDir, 
+    /** Accepted for back-compat; canonical SDK path executes every job
+     *  identically. Affects only UI display + budget heuristics elsewhere. */
+    _mode, maxHours, timeoutMs, successCriteria, agentSlug) {
         const releaseLane = await lanes.acquire('cron');
+        // Build a wall-clock abort timer from maxHours / timeoutMs.
+        // Whichever is shorter wins. Defaults to 1h if neither is set.
+        const wallMs = (() => {
+            const fromHours = maxHours && maxHours > 0 ? maxHours * 3600 * 1000 : null;
+            const fromMs = timeoutMs && timeoutMs > 0 ? timeoutMs : null;
+            if (fromHours && fromMs)
+                return Math.min(fromHours, fromMs);
+            return fromHours ?? fromMs ?? 60 * 60 * 1000;
+        })();
+        const cronAc = new AbortController();
+        const cronTimer = setTimeout(() => {
+            cronAc.abort();
+            logger.warn({ jobName, wallMs }, 'Cron job hit wall-clock cap — aborting');
+        }, wallMs);
         try {
             logger.info(`Running cron job: ${jobName}${workDir ? ` in ${workDir}` : ''}${agentSlug && agentSlug !== 'clementine' ? ` as ${agentSlug}` : ''}`);
-            events.emit('cron:start', { jobName, tier, mode: 'runagent', timestamp: Date.now() });
             const cronStart = Date.now();
             try {
                 const { runAgentCron } = await import('../agent/run-agent-cron.js');
                 const profile = agentSlug && agentSlug !== 'clementine'
                     ? this.getAgentManager().get(agentSlug) ?? null
                     : null;
-                logger.info({ jobName, agentSlug, tier, path: 'runagent_cron' }, 'Routing cron through runAgentCron');
+                logger.info({ jobName, agentSlug, tier, wallMs, path: 'runagent_cron' }, 'Routing cron through runAgentCron');
                 const cronResult = await runAgentCron({
                     jobName,
                     jobPrompt,
@@ -1948,15 +1980,10 @@ export class Gateway {
                     successCriteria,
                     model,
                     workDir,
+                    abortSignal: cronAc.signal,
                     postTaskHooks: this.assistant,
                 });
                 scanner.refreshIntegrity();
-                events.emit('cron:complete', {
-                    jobName,
-                    mode: 'runagent',
-                    durationMs: Date.now() - cronStart,
-                    responseLength: cronResult.text?.length ?? 0,
-                });
                 logger.info({
                     jobName,
                     cost: Number(cronResult.totalCostUsd.toFixed(4)),
@@ -1968,16 +1995,16 @@ export class Gateway {
                 return cronResult.text;
             }
             catch (err) {
-                events.emit('cron:error', { jobName, mode: 'runagent', error: String(err) });
                 logger.error({ err, jobName }, `Cron job error: ${jobName}`);
                 throw err;
             }
         }
         finally {
+            clearTimeout(cronTimer);
             releaseLane();
         }
     }
-    // ── Team task execution (unleashed for team messages) ──────────────
+    // ── Team task execution ──────────────────────────────────────────────
     /**
      * Process a team message as an autonomous task — same multi-phase execution
      * as cron unleashed jobs, so agents can work until done instead of being

package/dist/tools/admin-tools.js

@@ -992,7 +992,6 @@ export function registerAdminTools(server) {
             const schedule = String(job.schedule ?? '');
             const prompt = String(job.prompt ?? '');
             const enabled = job.enabled !== false;
-            const mode = job.mode === 'unleashed' ? 'unleashed' : 'standard';
             const workDir = job.work_dir ? String(job.work_dir) : null;
             const humanSchedule = describeCronSchedule(schedule);
             const nextRun = enabled ? getNextRun(schedule) : null;
@@ -1016,7 +1015,7 @@ export function registerAdminTools(server) {
                 }
             }
             const status = enabled ? 'enabled' : 'disabled';
-            lines.push(`**${name}** [${status}] ${mode === 'unleashed' ? '[unleashed] ' : ''}` +
+            lines.push(`**${name}** [${status}] ` +
                 `\n  Schedule: ${humanSchedule} (\`${schedule}\`)` +
                 (nextRun ? `\n  Next run: ${nextRun}` : '') +
                 (lastRunInfo ? `\n  ${lastRunInfo}` : '') +
@@ -1026,47 +1025,20 @@ export function registerAdminTools(server) {
         return textResult(lines.join('\n\n'));
     });
     // ── Add Cron Job ────────────────────────────────────────────────────────
-    server.tool('add_cron_job', 'Add a new scheduled cron job. Validates the schedule expression and writes to CRON.md. The daemon auto-reloads on file change. Use mode "unleashed" for multi-step tasks (browser automation, batch processing, multi-contact workflows) — they need more turns than standard mode provides. Auto-escalates to unleashed when complex patterns are detected.', {
+    server.tool('add_cron_job', 'Add a new scheduled cron job. Validates the schedule expression and writes to CRON.md. The daemon auto-reloads on file change. The canonical SDK path runs every job through runAgentCron — there is no separate "unleashed" mode anymore; the SDK handles compaction + multi-turn work natively up to maxBudgetUsd.', {
         name: z.string().describe('Job name (unique identifier)'),
         schedule: z.string().describe('Cron expression (e.g., "0 9 * * 1" for Monday 9 AM)'),
         prompt: z.string().describe('The prompt/instruction for the assistant to execute'),
-        tier: z.number().optional().default(1).describe('Security tier (1=auto, 2=logged, 3=approval)'),
+        tier: z.number().optional().default(1).describe('Security tier (1=auto, 2=logged, 3=approval). Tier 2+ also raises the per-run budget cap.'),
         enabled: z.boolean().optional().default(true).describe('Whether the job is enabled'),
         work_dir: z.string().optional().describe('Project directory to run in (agent gets access to project tools, CLAUDE.md, files)'),
-        mode: z.enum(['standard', 'unleashed']).optional().default('standard').describe('standard = normal cron, unleashed = long-running phased execution with checkpointing'),
-        max_hours: z.number().optional().describe('Max hours for unleashed mode (default 6). Ignored for standard mode.'),
-    }, async ({ name: jobName, schedule, prompt, tier, enabled, work_dir, mode: rawMode, max_hours: rawMaxHours }) => {
-        let mode = rawMode;
-        let max_hours = rawMaxHours;
+        max_hours: z.number().optional().describe('Wall-clock cap in hours. Defaults to 1h. Run aborts via AbortSignal when exceeded.'),
+    }, async ({ name: jobName, schedule, prompt, tier, enabled, work_dir, max_hours }) => {
         // Validate cron expression
         const cronMod = await import('node-cron');
         if (!cronMod.default.validate(schedule)) {
             return textResult(`Invalid cron expression: "${schedule}". Examples: "0 9 * * 1" (Mon 9 AM), "*/30 * * * *" (every 30 min).`);
         }
-        // Auto-escalate to unleashed when the job clearly needs it.
-        // Tier 2 jobs with complex prompts (browser automation, multi-contact workflows,
-        // multi-step sequences) will exhaust standard turn limits silently.
-        if (mode !== 'unleashed' && tier >= 2) {
-            const complexSignals = [
-                /\bfor each\b.*\bcontact\b/i,
-                /\bfor each\b.*\bprospect\b/i,
-                /\bfor each\b.*\baccount\b/i,
-                /\bfor each\b.*\blead\b/i,
-                /\bfor each\b.*\bprofile\b/i,
-                /\bplaywright\b/i,
-                /\bkernel\s+browsers?\b/i,
-                /\bbrowser\b.*\bautomati/i,
-                /\bstep\s+\d+\b.*\bstep\s+\d+\b/is,
-            ];
-            const isComplex = complexSignals.some(p => p.test(prompt))
-                || prompt.length > 2000;
-            if (isComplex) {
-                mode = 'unleashed';
-                if (!max_hours)
-                    max_hours = 1;
-                logger.info({ jobName }, 'Auto-escalated to unleashed mode (complex prompt detected)');
-            }
-        }
         // Read existing CRON.md or create empty structure
         const matterMod = await import('gray-matter');
         let parsed;
@@ -1097,11 +1069,8 @@ export function registerAdminTools(server) {
         };
         if (work_dir)
             newJob.work_dir = work_dir;
-        if (mode === 'unleashed') {
-            newJob.mode = 'unleashed';
-            if (max_hours)
-                newJob.max_hours = max_hours;
-        }
+        if (max_hours)
+            newJob.max_hours = max_hours;
         jobs.push(newJob);
         parsed.data.jobs = jobs;
         // Write back preserving body content — validate first to prevent daemon crash
@@ -1113,7 +1082,7 @@ export function registerAdminTools(server) {
             return textResult(`Failed to add job "${jobName}": generated YAML is invalid. Error: ${yamlErr}`);
         }
         writeFileSync(CRON_FILE, output);
-        logger.info({ jobName, schedule, tier, mode, work_dir }, 'Added cron job via MCP tool');
+        logger.info({ jobName, schedule, tier, work_dir, max_hours }, 'Added cron job via MCP tool');
         // Read-back verification: confirm the job was persisted correctly
         let verified = false;
         try {
@@ -1134,10 +1103,8 @@ export function registerAdminTools(server) {
         ];
         if (work_dir)
             details.push(`  Project: ${work_dir}`);
-        if (mode === 'unleashed') {
-            const escalated = rawMode !== 'unleashed' ? ' (auto-escalated — complex prompt detected)' : '';
-            details.push(`  Mode: unleashed (max ${max_hours ?? 6} hours)${escalated}`);
-        }
+        if (max_hours)
+            details.push(`  Wall-clock cap: ${max_hours}h`);
         const verifyMsg = verified
             ? 'Verified: job persisted to CRON.md and will be picked up by the daemon.'
             : 'WARNING: Could not verify the job was written correctly. Check CRON.md manually.';

package/dist/types.d.ts

@@ -196,6 +196,25 @@ export interface AgentProfile {
         start: number;
         end: number;
     };
+    /**
+     * Short imperative routing hints used to build this agent's
+     * AgentDefinition.description for SDK auto-routing. Each entry is a
+     * capability phrase the main agent might match against user input
+     * (e.g., "outbound prospect emails", "content calendar drafting").
+     * Free-form strings, comma-joined when assembled. Optional.
+     */
+    routingHints?: string[];
+    /**
+     * Short label describing the role (e.g., "SDR", "CMO"). Used in the
+     * routing description when present.
+     */
+    role?: string;
+    /**
+     * SDK reasoning effort tier when this profile runs as a subagent.
+     * Defaults to 'medium' if unset. Low = Haiku-style cheap fanout,
+     * High = deep reasoning, Max = max effort.
+     */
+    effort?: 'low' | 'medium' | 'high' | 'xhigh' | 'max';
 }
 export type AgentStatus = 'active' | 'paused' | 'error' | 'terminated';
 export interface HeartbeatReportedTopic {
@@ -299,7 +318,12 @@ export interface CronJobDefinition {
     maxTurns?: number;
     model?: string;
     workDir?: string;
+    /** Display/intent hint — 'unleashed' jobs are typically long autonomous
+     *  tasks. The canonical SDK path runs every job through runAgentCron
+     *  identically; this field affects only UI badges + budget heuristics. */
     mode?: 'standard' | 'unleashed';
+    /** Wall-clock cap in hours. Defaults to 1h. Triggers an AbortSignal
+     *  on the runAgentCron call when exceeded. */
     maxHours?: number;
     maxRetries?: number;
     after?: string;

package/package.json

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

package/dist/events/bus.d.ts

@@ -1,43 +0,0 @@
-/**
- * Clementine TypeScript — Event Bus.
- *
- * Typed pub/sub system for decoupling gateway lifecycle events from consumers.
- * Plugins, logging, metrics, and UI can subscribe without modifying core code.
- *
- * Events are fire-and-forget (async handlers don't block the emitter).
- * "before" events return a boolean — false cancels the operation.
- */
-export type EventHandler<T = unknown> = (payload: T) => void | Promise<void>;
-export type BeforeHandler<T = unknown> = (payload: T) => boolean | Promise<boolean>;
-declare class EventBus {
-    private listeners;
-    private beforeHandlers;
-    /**
-     * Subscribe to an event. Handler is called asynchronously (fire-and-forget).
-     * Returns an unsubscribe function.
-     */
-    on<T = unknown>(event: string, handler: EventHandler<T>): () => void;
-    /** Subscribe to an event, but only fire once. */
-    once<T = unknown>(event: string, handler: EventHandler<T>): () => void;
-    /**
-     * Register a "before" handler that can cancel an operation.
-     * If any before handler returns false, the operation is cancelled.
-     */
-    before<T = unknown>(event: string, handler: BeforeHandler<T>): () => void;
-    /**
-     * Emit an event asynchronously. Handlers run in parallel, errors are logged but don't propagate.
-     */
-    emit<T = unknown>(event: string, payload: T): void;
-    /**
-     * Run "before" handlers sequentially. Returns true if all pass, false if any cancels.
-     */
-    emitBefore<T = unknown>(event: string, payload: T): Promise<boolean>;
-    /** Remove all listeners for an event, or all events if no event specified. */
-    clear(event?: string): void;
-    /** Get count of listeners for an event (useful for debugging). */
-    listenerCount(event: string): number;
-}
-/** Singleton event bus — shared across the entire process. */
-export declare const events: EventBus;
-export {};
-//# sourceMappingURL=bus.d.ts.map

package/dist/events/bus.js

@@ -1,136 +0,0 @@
-/**
- * Clementine TypeScript — Event Bus.
- *
- * Typed pub/sub system for decoupling gateway lifecycle events from consumers.
- * Plugins, logging, metrics, and UI can subscribe without modifying core code.
- *
- * Events are fire-and-forget (async handlers don't block the emitter).
- * "before" events return a boolean — false cancels the operation.
- */
-import pino from 'pino';
-const logger = pino({ name: 'clementine.events' });
-class EventBus {
-    listeners = new Map();
-    beforeHandlers = new Map();
-    /**
-     * Subscribe to an event. Handler is called asynchronously (fire-and-forget).
-     * Returns an unsubscribe function.
-     */
-    on(event, handler) {
-        const subs = this.listeners.get(event) ?? [];
-        const sub = { handler: handler, once: false };
-        subs.push(sub);
-        this.listeners.set(event, subs);
-        return () => {
-            const list = this.listeners.get(event);
-            if (list) {
-                const idx = list.indexOf(sub);
-                if (idx !== -1)
-                    list.splice(idx, 1);
-            }
-        };
-    }
-    /** Subscribe to an event, but only fire once. */
-    once(event, handler) {
-        const subs = this.listeners.get(event) ?? [];
-        const sub = { handler: handler, once: true };
-        subs.push(sub);
-        this.listeners.set(event, subs);
-        return () => {
-            const list = this.listeners.get(event);
-            if (list) {
-                const idx = list.indexOf(sub);
-                if (idx !== -1)
-                    list.splice(idx, 1);
-            }
-        };
-    }
-    /**
-     * Register a "before" handler that can cancel an operation.
-     * If any before handler returns false, the operation is cancelled.
-     */
-    before(event, handler) {
-        const handlers = this.beforeHandlers.get(event) ?? [];
-        const entry = { handler: handler, once: false };
-        handlers.push(entry);
-        this.beforeHandlers.set(event, handlers);
-        return () => {
-            const list = this.beforeHandlers.get(event);
-            if (list) {
-                const idx = list.findIndex(e => e === entry);
-                if (idx !== -1)
-                    list.splice(idx, 1);
-            }
-        };
-    }
-    /**
-     * Emit an event asynchronously. Handlers run in parallel, errors are logged but don't propagate.
-     */
-    emit(event, payload) {
-        const subs = this.listeners.get(event);
-        if (!subs || subs.length === 0)
-            return;
-        // Snapshot handlers and remove once-listeners
-        const handlers = [...subs];
-        for (let i = subs.length - 1; i >= 0; i--) {
-            if (subs[i].once)
-                subs.splice(i, 1);
-        }
-        for (const sub of handlers) {
-            try {
-                const result = sub.handler(payload);
-                if (result instanceof Promise) {
-                    result.catch(err => logger.warn({ err, event }, 'Event handler error'));
-                }
-            }
-            catch (err) {
-                logger.warn({ err, event }, 'Event handler error (sync)');
-            }
-        }
-    }
-    /**
-     * Run "before" handlers sequentially. Returns true if all pass, false if any cancels.
-     */
-    async emitBefore(event, payload) {
-        const handlers = this.beforeHandlers.get(event);
-        if (!handlers || handlers.length === 0)
-            return true;
-        for (const entry of [...handlers]) {
-            try {
-                const result = entry.handler(payload);
-                const allowed = result instanceof Promise ? await result : result;
-                if (!allowed) {
-                    logger.info({ event }, 'Operation cancelled by before handler');
-                    return false;
-                }
-            }
-            catch (err) {
-                logger.warn({ err, event }, 'Before handler error — allowing operation');
-            }
-            if (entry.once) {
-                const idx = handlers.indexOf(entry);
-                if (idx !== -1)
-                    handlers.splice(idx, 1);
-            }
-        }
-        return true;
-    }
-    /** Remove all listeners for an event, or all events if no event specified. */
-    clear(event) {
-        if (event) {
-            this.listeners.delete(event);
-            this.beforeHandlers.delete(event);
-        }
-        else {
-            this.listeners.clear();
-            this.beforeHandlers.clear();
-        }
-    }
-    /** Get count of listeners for an event (useful for debugging). */
-    listenerCount(event) {
-        return (this.listeners.get(event)?.length ?? 0) + (this.beforeHandlers.get(event)?.length ?? 0);
-    }
-}
-/** Singleton event bus — shared across the entire process. */
-export const events = new EventBus();
-//# sourceMappingURL=bus.js.map