@agentconnect/host 0.2.4 → 0.2.6

package/dist/host.js

@@ -5,11 +5,11 @@ import fs from 'fs';
 import { promises as fsp } from 'fs';
 import net from 'net';
 import path from 'path';
-import { listModels, listRecentModels, providers, resolveProviderForModel } from './providers/index.js';
+import { listModels, listRecentModels, providers, resolveProviderForModel, } from './providers/index.js';
 import { debugLog, setSpawnLogging } from './providers/utils.js';
 import { createObservedTracker } from './observed.js';
 import { createStorage } from './storage.js';
-import { buildSummaryPrompt, getSummaryModel, pollClaudeSummary, runSummaryPrompt, } from './summary.js';
+import { buildSummaryPrompt, buildSummaryPromptWithOverride, getSummaryModel, runSummaryPrompt, } from './summary.js';
 function send(socket, payload) {
     socket.send(JSON.stringify(payload));
 }
@@ -33,8 +33,7 @@ function buildProviderList(statuses) {
     });
 }
 function resolveLoginExperience(mode) {
-    const raw = process.env.AGENTCONNECT_LOGIN_EXPERIENCE ||
-        process.env.AGENTCONNECT_CLAUDE_LOGIN_EXPERIENCE;
+    const raw = process.env.AGENTCONNECT_LOGIN_EXPERIENCE || process.env.AGENTCONNECT_CLAUDE_LOGIN_EXPERIENCE;
     if (raw) {
         const normalized = raw.trim().toLowerCase();
         if (normalized === 'terminal' || normalized === 'manual')
@@ -127,6 +126,29 @@ function createHostRuntime(options) {
             return null;
         }
     }
+    function normalizeSummaryMode(value) {
+        const raw = typeof value === 'string' ? value.trim().toLowerCase() : '';
+        if (raw === 'auto' || raw === 'off' || raw === 'force')
+            return raw;
+        return undefined;
+    }
+    function normalizeSummaryPrompt(value) {
+        if (typeof value !== 'string')
+            return undefined;
+        const trimmed = value.trim();
+        return trimmed ? trimmed : undefined;
+    }
+    function resolveSummaryMode(session, requested) {
+        if (requested)
+            return requested;
+        return session.summaryMode ?? 'auto';
+    }
+    function resolveEffectiveSummaryMode(session, requested) {
+        const mode = resolveSummaryMode(session, requested);
+        if (mode === 'auto' && session.summaryAutoUsed)
+            return 'off';
+        return mode;
+    }
     function recordCapability(capability) {
         observedTracker.record(capability);
     }
@@ -139,6 +161,17 @@ function createHostRuntime(options) {
     function recordProviderCapability(providerId) {
         recordCapability(`model.${providerId}`);
     }
+    function resolveSystemPrompt(providerId, input) {
+        if (typeof input === 'string') {
+            const trimmed = input.trim();
+            return trimmed ? trimmed : undefined;
+        }
+        const envKey = `AGENTCONNECT_SYSTEM_PROMPT_${providerId.toUpperCase()}`;
+        const envValue = process.env[envKey];
+        if (envValue && envValue.trim())
+            return envValue.trim();
+        return undefined;
+    }
     const SUMMARY_REASONING_MAX_LINES = 3;
     const SUMMARY_REASONING_MAX_CHARS = 280;
     function appendSummaryReasoning(session, text) {
@@ -173,62 +206,57 @@ function createHostRuntime(options) {
     function clearSummarySeed(session) {
         session.summarySeed = undefined;
         session.summaryReasoning = undefined;
+        session.summaryNextMode = undefined;
+        session.summaryNextPrompt = undefined;
     }
     async function startPromptSummary(options) {
-        const { sessionId, session, message, reasoning, emit } = options;
-        if (session.providerId === 'claude')
-            return;
+        const { sessionId, session, message, reasoning, summaryPrompt, mode, emit } = options;
         if (session.summaryRequested)
             return;
         session.summaryRequested = true;
-        const provider = providers[session.providerId];
-        if (!provider)
-            return;
-        const prompt = buildSummaryPrompt(message, reasoning);
-        const summaryModel = getSummaryModel(session.providerId);
-        const cwd = session.cwd || basePath;
-        const repoRoot = session.repoRoot || basePath;
-        const result = await runSummaryPrompt({
-            provider,
-            prompt,
-            model: summaryModel,
-            cwd,
-            repoRoot,
-        });
-        if (!result)
-            return;
-        persistSummary(emit, sessionId, {
-            summary: result.summary,
-            source: 'prompt',
-            provider: session.providerId,
-            model: result.model ?? null,
-            createdAt: new Date().toISOString(),
-        }, session);
-    }
-    async function startClaudeLogSummary(options) {
-        const { sessionId, session, emit } = options;
-        if (session.providerId !== 'claude')
-            return;
-        if (session.claudeSummaryWatch)
-            return;
-        const providerSessionId = session.providerSessionId;
-        if (!providerSessionId)
-            return;
-        session.claudeSummaryWatch = true;
-        const projectRoot = session.repoRoot || session.cwd || basePath;
-        const summary = await pollClaudeSummary({
-            basePath: projectRoot,
-            sessionId: providerSessionId,
-        });
-        if (!summary)
-            return;
-        persistSummary(emit, sessionId, {
-            summary,
-            source: 'claude-log',
-            provider: 'claude',
-            model: session.model ?? null,
-            createdAt: new Date().toISOString(),
-        }, session);
+        let completed = false;
+        try {
+            const provider = providers[session.providerId];
+            if (!provider)
+                return;
+            const prompt = summaryPrompt
+                ? buildSummaryPromptWithOverride(summaryPrompt, message, reasoning)
+                : buildSummaryPrompt(message, reasoning);
+            const summaryModel = getSummaryModel(session.providerId);
+            const cwd = session.cwd || basePath;
+            const repoRoot = session.repoRoot || basePath;
+            const result = await runSummaryPrompt({
+                provider,
+                prompt,
+                model: summaryModel,
+                cwd,
+                repoRoot,
+            });
+            if (!result)
+                return;
+            persistSummary(emit, sessionId, {
+                summary: result.summary,
+                source: 'prompt',
+                provider: session.providerId,
+                model: result.model ?? null,
+                createdAt: new Date().toISOString(),
+            }, session);
+            completed = true;
+        }
+        finally {
+            session.summaryRequested = false;
+            if (!completed && mode === 'auto') {
+                session.summaryAutoUsed = true;
+            }
+            if (session.summarySeed) {
+                maybeStartPromptSummary({
+                    sessionId,
+                    session,
+                    emit,
+                    trigger: 'output',
+                });
+            }
+        }
     }
     async function getCachedStatus(provider, options = {}) {
         if (options.force) {
@@ -346,7 +374,8 @@ function createHostRuntime(options) {
     }
     function maybeStartPromptSummary(options) {
         const { sessionId, session, emit, trigger } = options;
-        if (session.providerId === 'claude')
+        const mode = resolveEffectiveSummaryMode(session, session.summaryNextMode);
+        if (mode === 'off')
             return;
         if (session.summaryRequested)
             return;
@@ -356,8 +385,17 @@ function createHostRuntime(options) {
             return;
         const message = session.summarySeed;
         const reasoning = session.summaryReasoning;
+        const summaryPrompt = session.summaryNextPrompt ?? session.summaryPrompt;
         clearSummarySeed(session);
-        void startPromptSummary({ sessionId, session, message, reasoning, emit });
+        void startPromptSummary({
+            sessionId,
+            session,
+            message,
+            reasoning,
+            summaryPrompt,
+            mode,
+            emit,
+        });
     }
     function sessionSummaryKey(sessionId) {
         return `session:${sessionId}:summary`;
@@ -366,9 +404,6 @@ function createHostRuntime(options) {
         if (!payload.summary)
             return;
         if (session) {
-            if (session.summarySource === 'claude-log' && payload.source === 'prompt') {
-                return;
-            }
             if (session.summary === payload.summary && session.summarySource === payload.source) {
                 return;
             }
@@ -376,6 +411,7 @@ function createHostRuntime(options) {
             session.summarySource = payload.source;
             session.summaryModel = payload.model ?? null;
             session.summaryCreatedAt = payload.createdAt;
+            session.summaryAutoUsed = true;
         }
         emitSessionEvent(emit, sessionId, 'summary', payload);
         storage.set(sessionSummaryKey(sessionId), payload);
@@ -598,6 +634,7 @@ function createHostRuntime(options) {
                 model = await pickDefaultModel(rawProvider);
             }
             const reasoningEffort = params.reasoningEffort || null;
+            const systemPrompt = resolveSystemPrompt(providerId, params.system);
             const cwd = params.cwd ? resolveAppPathInternal(params.cwd) : undefined;
             const repoRoot = params.repoRoot ? resolveAppPathInternal(params.repoRoot) : undefined;
             const providerDetailLevel = params.providerDetailLevel || undefined;
@@ -607,6 +644,8 @@ function createHostRuntime(options) {
             else {
                 recordProviderCapability(providerId);
             }
+            const summaryMode = normalizeSummaryMode(params.summary?.mode);
+            const summaryPrompt = normalizeSummaryPrompt(params.summary?.prompt);
             sessions.set(sessionId, {
                 id: sessionId,
                 providerId,
@@ -615,9 +654,13 @@ function createHostRuntime(options) {
                 reasoningEffort,
                 cwd,
                 repoRoot,
+                systemPrompt,
                 providerDetailLevel: providerDetailLevel === 'raw' || providerDetailLevel === 'minimal'
                     ? providerDetailLevel
                     : undefined,
+                summaryMode: summaryMode === 'force' ? 'auto' : summaryMode ?? 'auto',
+                summaryPrompt,
+                summaryAutoUsed: false,
             });
             responder.reply(id, { sessionId });
             return;
@@ -638,12 +681,25 @@ function createHostRuntime(options) {
             if (params.repoRoot) {
                 existing.repoRoot = resolveAppPathInternal(params.repoRoot);
             }
+            if ('system' in params) {
+                existing.systemPrompt = resolveSystemPrompt(existing.providerId, params.system);
+            }
             if (params.providerDetailLevel) {
                 const level = String(params.providerDetailLevel);
                 if (level === 'raw' || level === 'minimal') {
                     existing.providerDetailLevel = level;
                 }
             }
+            if ('summary' in params) {
+                const summaryMode = normalizeSummaryMode(params.summary?.mode);
+                const summaryPrompt = normalizeSummaryPrompt(params.summary?.prompt);
+                if (summaryMode) {
+                    existing.summaryMode = summaryMode === 'force' ? 'auto' : summaryMode;
+                }
+                if (summaryPrompt !== undefined) {
+                    existing.summaryPrompt = summaryPrompt;
+                }
+            }
             if (!existing.model && typeof params.model === 'string' && params.model.trim()) {
                 const candidate = params.model.trim();
                 const matches = await isModelForProvider(candidate, existing.providerId);
@@ -699,10 +755,13 @@ function createHostRuntime(options) {
                     return;
                 }
             }
-            if (message.trim() &&
-                session.providerId !== 'claude' &&
-                !session.summaryRequested &&
-                !session.summarySeed) {
+            const summaryMode = resolveEffectiveSummaryMode(session, normalizeSummaryMode(params.summary?.mode));
+            const summaryPrompt = normalizeSummaryPrompt(params.summary?.prompt);
+            session.summaryNextMode = summaryMode;
+            if (summaryPrompt !== undefined) {
+                session.summaryNextPrompt = summaryPrompt;
+            }
+            if (summaryMode !== 'off' && message.trim()) {
                 session.summarySeed = message;
                 session.summaryReasoning = '';
             }
@@ -726,6 +785,7 @@ function createHostRuntime(options) {
                 repoRoot,
                 cwd,
                 providerDetailLevel,
+                system: session.systemPrompt,
                 signal: controller.signal,
                 onEvent: (event) => {
                     const current = activeRuns.get(sessionId);
@@ -746,9 +806,7 @@ function createHostRuntime(options) {
                             trigger: 'reasoning',
                         });
                     }
-                    if (event.type === 'delta' ||
-                        event.type === 'message' ||
-                        event.type === 'final') {
+                    if (event.type === 'delta' || event.type === 'message' || event.type === 'final') {
                         maybeStartPromptSummary({
                             sessionId,
                             session,
@@ -765,7 +823,6 @@ function createHostRuntime(options) {
                     return;
                 if (result?.sessionId) {
                     session.providerSessionId = result.sessionId;
-                    void startClaudeLogSummary({ sessionId, session, emit: responder.emit });
                 }
             })
                 .catch((err) => {

package/dist/providers/claude.d.ts

@@ -9,4 +9,4 @@ export declare function updateClaude(): Promise<ProviderStatus>;
 export declare function loginClaude(options?: ProviderLoginOptions): Promise<{
     loggedIn: boolean;
 }>;
-export declare function runClaudePrompt({ prompt, resumeSessionId, model, cwd, providerDetailLevel, onEvent, signal, }: RunPromptOptions): Promise<RunPromptResult>;
+export declare function runClaudePrompt({ prompt, system, resumeSessionId, model, cwd, providerDetailLevel, onEvent, signal, }: RunPromptOptions): Promise<RunPromptResult>;

package/dist/providers/claude.js

@@ -184,7 +184,10 @@ function formatClaudeDisplayName(modelId) {
     const value = modelId.trim();
     if (!value.startsWith('claude-'))
         return value;
-    const parts = value.replace(/^claude-/, '').split('-').filter(Boolean);
+    const parts = value
+        .replace(/^claude-/, '')
+        .split('-')
+        .filter(Boolean);
     if (!parts.length)
         return value;
     const family = parts[0];
@@ -560,8 +563,7 @@ async function checkClaudeCliStatus() {
                         : typeof message?.error === 'string'
                             ? message.error
                             : '';
-                    if (isClaudeAuthErrorText(text) ||
-                        (errorText && isClaudeAuthErrorText(errorText))) {
+                    if (isClaudeAuthErrorText(text) || (errorText && isClaudeAuthErrorText(errorText))) {
                         authError = authError ?? (text || errorText);
                     }
                     else if (text.trim()) {
@@ -901,6 +903,180 @@ function mapClaudeModel(model) {
         return value.replace('claude-', '');
     return model;
 }
+function extractUsageFromValue(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const usage = value;
+    const toNumber = (v) => {
+        if (typeof v === 'number' && Number.isFinite(v))
+            return v;
+        if (typeof v === 'string' && v.trim()) {
+            const parsed = Number(v);
+            return Number.isFinite(parsed) ? parsed : undefined;
+        }
+        return undefined;
+    };
+    const input = toNumber(usage.input_tokens ?? usage.prompt_tokens ?? usage.inputTokens ?? usage.promptTokens);
+    const output = toNumber(usage.output_tokens ?? usage.completion_tokens ?? usage.outputTokens ?? usage.completionTokens);
+    const total = toNumber(usage.total_tokens ?? usage.totalTokens);
+    let cached = toNumber(usage.cached_input_tokens ?? usage.cachedInputTokens);
+    const cacheCreation = toNumber(usage.cache_creation_input_tokens ?? usage.cacheCreationInputTokens);
+    const cacheRead = toNumber(usage.cache_read_input_tokens ?? usage.cacheReadInputTokens);
+    if (cached === undefined) {
+        const sum = (cacheCreation ?? 0) + (cacheRead ?? 0);
+        if (sum > 0)
+            cached = sum;
+    }
+    const reasoning = toNumber(usage.reasoning_tokens ?? usage.reasoningTokens);
+    const out = {};
+    if (input !== undefined)
+        out.input_tokens = input;
+    if (output !== undefined)
+        out.output_tokens = output;
+    if (total !== undefined)
+        out.total_tokens = total;
+    if (cached !== undefined)
+        out.cached_input_tokens = cached;
+    if (reasoning !== undefined)
+        out.reasoning_tokens = reasoning;
+    return Object.keys(out).length ? out : null;
+}
+function pickModelUsage(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const entries = Object.values(value);
+    for (const entry of entries) {
+        if (entry && typeof entry === 'object')
+            return entry;
+    }
+    return null;
+}
+function extractClaudeUsage(msg) {
+    const usage = msg.usage ??
+        msg.message?.usage ??
+        msg.event?.usage ??
+        msg.delta?.usage ??
+        msg.token_usage ??
+        msg.tokenUsage;
+    if (usage)
+        return extractUsageFromValue(usage);
+    const resultRecord = msg.result && typeof msg.result === 'object' ? msg.result : null;
+    const nestedUsage = resultRecord?.usage ??
+        resultRecord?.token_usage ??
+        resultRecord?.tokenUsage ??
+        resultRecord?.token_usage;
+    if (nestedUsage)
+        return extractUsageFromValue(nestedUsage);
+    const modelUsage = pickModelUsage(msg.modelUsage ?? msg.message?.modelUsage ?? resultRecord?.modelUsage);
+    return extractUsageFromValue(modelUsage);
+}
+function extractClaudeContextUsage(msg, usage) {
+    const context = msg.context_usage ??
+        msg.contextUsage ??
+        msg.message?.context_usage ??
+        msg.message?.contextUsage ??
+        msg.event?.context_usage ??
+        msg.event?.contextUsage;
+    const resultRecord = msg.result && typeof msg.result === 'object' ? msg.result : null;
+    const modelUsage = pickModelUsage(msg.modelUsage ?? msg.message?.modelUsage ?? resultRecord?.modelUsage);
+    const toNumber = (v) => {
+        if (typeof v === 'number' && Number.isFinite(v))
+            return v;
+        if (typeof v === 'string' && v.trim()) {
+            const parsed = Number(v);
+            return Number.isFinite(parsed) ? parsed : undefined;
+        }
+        return undefined;
+    };
+    const toBoolean = (v) => typeof v === 'boolean' ? v : undefined;
+    const contextWindow = toNumber(context?.context_window ??
+        context?.contextWindow ??
+        modelUsage?.contextWindow ??
+        modelUsage?.context_window ??
+        msg.context_window ??
+        msg.contextWindow);
+    let contextTokens = toNumber(context?.context_tokens ??
+        context?.contextTokens ??
+        msg.context_tokens ??
+        msg.contextTokens);
+    let contextCachedTokens = toNumber(context?.context_cached_tokens ??
+        context?.contextCachedTokens ??
+        msg.context_cached_tokens ??
+        msg.contextCachedTokens);
+    let contextRemainingTokens = toNumber(context?.context_remaining_tokens ??
+        context?.contextRemainingTokens ??
+        msg.context_remaining_tokens ??
+        msg.contextRemainingTokens);
+    const contextTruncated = toBoolean(context?.context_truncated ??
+        context?.contextTruncated ??
+        msg.context_truncated ??
+        msg.contextTruncated);
+    if (contextCachedTokens === undefined) {
+        const cached = toNumber(context?.cache_creation_input_tokens) ??
+            toNumber(context?.cacheCreationInputTokens) ??
+            toNumber(context?.cache_read_input_tokens) ??
+            toNumber(context?.cacheReadInputTokens);
+        if (cached !== undefined)
+            contextCachedTokens = cached;
+    }
+    if (contextTokens === undefined) {
+        if (usage?.input_tokens !== undefined &&
+            usage?.cached_input_tokens !== undefined) {
+            contextTokens = usage.input_tokens + usage.cached_input_tokens;
+        }
+        else if (usage?.input_tokens !== undefined) {
+            contextTokens = usage.input_tokens;
+        }
+    }
+    if (contextCachedTokens === undefined && usage?.cached_input_tokens !== undefined) {
+        contextCachedTokens = usage.cached_input_tokens;
+    }
+    if (contextRemainingTokens === undefined &&
+        contextWindow !== undefined &&
+        contextTokens !== undefined) {
+        contextRemainingTokens = Math.max(0, contextWindow - contextTokens);
+    }
+    const out = {};
+    if (contextWindow !== undefined)
+        out.context_window = contextWindow;
+    if (contextTokens !== undefined)
+        out.context_tokens = contextTokens;
+    if (contextCachedTokens !== undefined)
+        out.context_cached_tokens = contextCachedTokens;
+    if (contextRemainingTokens !== undefined)
+        out.context_remaining_tokens = contextRemainingTokens;
+    if (contextTruncated !== undefined)
+        out.context_truncated = contextTruncated;
+    return Object.keys(out).length ? out : null;
+}
+function mergeUsage(current, next) {
+    const out = { ...(current ?? {}) };
+    if (next.input_tokens !== undefined)
+        out.input_tokens = next.input_tokens;
+    if (next.output_tokens !== undefined)
+        out.output_tokens = next.output_tokens;
+    if (next.total_tokens !== undefined)
+        out.total_tokens = next.total_tokens;
+    if (next.cached_input_tokens !== undefined)
+        out.cached_input_tokens = next.cached_input_tokens;
+    if (next.reasoning_tokens !== undefined)
+        out.reasoning_tokens = next.reasoning_tokens;
+    return out;
+}
+function mergeContextUsage(current, next) {
+    const out = { ...(current ?? {}) };
+    if (next.context_window !== undefined)
+        out.context_window = next.context_window;
+    if (next.context_tokens !== undefined)
+        out.context_tokens = next.context_tokens;
+    if (next.context_cached_tokens !== undefined)
+        out.context_cached_tokens = next.context_cached_tokens;
+    if (next.context_remaining_tokens !== undefined)
+        out.context_remaining_tokens = next.context_remaining_tokens;
+    if (next.context_truncated !== undefined)
+        out.context_truncated = next.context_truncated;
+    return out;
+}
 function extractSessionId(msg) {
     const direct = msg.session_id ?? msg.sessionId;
     if (typeof direct === 'string' && direct)
@@ -960,7 +1136,7 @@ function extractResultText(msg) {
     const text = msg.result;
     return typeof text === 'string' && text ? text : null;
 }
-export function runClaudePrompt({ prompt, resumeSessionId, model, cwd, providerDetailLevel, onEvent, signal, }) {
+export function runClaudePrompt({ prompt, system, resumeSessionId, model, cwd, providerDetailLevel, onEvent, signal, }) {
     return new Promise((resolve) => {
         const command = getClaudeCommand();
         const args = [
@@ -970,6 +1146,10 @@ export function runClaudePrompt({ prompt, resumeSessionId, model, cwd, providerD
             '--permission-mode',
             'bypassPermissions',
         ];
+        const systemPrompt = typeof system === 'string' ? system.trim() : '';
+        if (systemPrompt) {
+            args.push('--append-system-prompt', systemPrompt);
+        }
         const modelValue = mapClaudeModel(model);
         if (modelValue) {
             args.push('--model', modelValue);
@@ -998,6 +1178,11 @@ export function runClaudePrompt({ prompt, resumeSessionId, model, cwd, providerD
         let finalSessionId = null;
         let didFinalize = false;
         let sawError = false;
+        let usageEmitted = false;
+        let latestUsage = null;
+        let latestContextUsage = null;
+        let latestUsageDetail;
+        let latestContextUsageDetail;
         const toolBlocks = new Map();
         const thinkingBlocks = new Set();
         const includeRaw = providerDetailLevel === 'raw';
@@ -1021,11 +1206,46 @@ export function runClaudePrompt({ prompt, resumeSessionId, model, cwd, providerD
             if (sawError)
                 return;
             sawError = true;
+            emitUsageIfAvailable();
             emit({ type: 'error', message });
         };
         const emitFinal = (text, providerDetail) => {
+            emitUsageIfAvailable();
             emit({ type: 'final', text, providerDetail });
         };
+        const captureUsage = (msg, providerDetail) => {
+            const usage = extractClaudeUsage(msg);
+            if (usage) {
+                latestUsage = mergeUsage(latestUsage, usage);
+                latestUsageDetail = providerDetail;
+            }
+            const contextUsage = extractClaudeContextUsage(msg, latestUsage);
+            if (contextUsage) {
+                latestContextUsage = mergeContextUsage(latestContextUsage, contextUsage);
+                latestContextUsageDetail = providerDetail;
+            }
+        };
+        const emitUsageIfAvailable = () => {
+            if (usageEmitted)
+                return;
+            if (!latestUsage && !latestContextUsage)
+                return;
+            if (latestUsage) {
+                emit({
+                    type: 'usage',
+                    usage: latestUsage,
+                    providerDetail: latestUsageDetail,
+                });
+            }
+            if (latestContextUsage) {
+                emit({
+                    type: 'context_usage',
+                    contextUsage: latestContextUsage,
+                    providerDetail: latestContextUsageDetail ?? latestUsageDetail,
+                });
+            }
+            usageEmitted = true;
+        };
         const handleLine = (line) => {
             const parsed = safeJsonParse(line);
             if (!parsed || typeof parsed !== 'object') {
@@ -1040,6 +1260,8 @@ export function runClaudePrompt({ prompt, resumeSessionId, model, cwd, providerD
                 finalSessionId = sid;
             const msgType = String(msg.type ?? '');
             let handled = false;
+            const detail = buildProviderDetail(msgType || 'unknown', {}, msg);
+            captureUsage(msg, detail);
             if (msgType === 'assistant' || msgType === 'user' || msgType === 'system') {
                 const role = msg.message?.role === 'assistant' ||
                     msg.message?.role === 'user' ||
@@ -1054,7 +1276,7 @@ export function runClaudePrompt({ prompt, resumeSessionId, model, cwd, providerD
                     role,
                     content,
                     contentParts: rawContent ?? null,
-                    providerDetail: buildProviderDetail(msgType, {}, msg),
+                    providerDetail: detail,
                 });
                 handled = true;
             }
@@ -1063,7 +1285,9 @@ export function runClaudePrompt({ prompt, resumeSessionId, model, cwd, providerD
                 const index = typeof msg.event.index === 'number' ? msg.event.index : undefined;
                 const block = msg.event.content_block;
                 if (evType === 'content_block_start' && block && typeof index === 'number') {
-                    if (block.type === 'tool_use' || block.type === 'server_tool_use' || block.type === 'mcp_tool_use') {
+                    if (block.type === 'tool_use' ||
+                        block.type === 'server_tool_use' ||
+                        block.type === 'mcp_tool_use') {
                         toolBlocks.set(index, { id: block.id, name: block.name });
                         emit({
                             type: 'tool_call',
@@ -1144,7 +1368,7 @@ export function runClaudePrompt({ prompt, resumeSessionId, model, cwd, providerD
                 emit({
                     type: 'delta',
                     text: delta,
-                    providerDetail: buildProviderDetail(msgType || 'delta', {}, msg),
+                    providerDetail: detail,
                 });
                 return;
             }
@@ -1154,21 +1378,21 @@ export function runClaudePrompt({ prompt, resumeSessionId, model, cwd, providerD
                 emit({
                     type: 'delta',
                     text: assistant,
-                    providerDetail: buildProviderDetail(msgType || 'assistant', {}, msg),
+                    providerDetail: detail,
                 });
                 return;
             }
             const result = extractResultText(msg);
             if (result && !didFinalize && !sawError) {
                 didFinalize = true;
-                emitFinal(aggregated || result, buildProviderDetail('result', {}, msg));
+                emitFinal(aggregated || result, detail);
                 handled = true;
             }
             if (!handled) {
                 emit({
                     type: 'detail',
                     provider: 'claude',
-                    providerDetail: buildProviderDetail(msgType || 'unknown', {}, msg),
+                    providerDetail: detail,
                 });
             }
         };
@@ -1185,6 +1409,9 @@ export function runClaudePrompt({ prompt, resumeSessionId, model, cwd, providerD
                     emitFinal(aggregated);
                 }
             }
+            if (!usageEmitted) {
+                emitUsageIfAvailable();
+            }
             resolve({ sessionId: finalSessionId });
         });
         child.on('error', (err) => {

package/dist/providers/codex.d.ts

@@ -8,4 +8,4 @@ export declare function loginCodex(): Promise<{
     loggedIn: boolean;
 }>;
 export declare function listCodexModels(): Promise<ModelInfo[]>;
-export declare function runCodexPrompt({ prompt, resumeSessionId, model, reasoningEffort, repoRoot, cwd, providerDetailLevel, onEvent, signal, }: RunPromptOptions): Promise<RunPromptResult>;
+export declare function runCodexPrompt({ prompt, system, resumeSessionId, model, reasoningEffort, repoRoot, cwd, providerDetailLevel, onEvent, signal, }: RunPromptOptions): Promise<RunPromptResult>;

package/dist/providers/codex.js

@@ -3,7 +3,7 @@ import { readFile } from 'fs/promises';
 import https from 'https';
 import os from 'os';
 import path from 'path';
-import { buildInstallCommandAuto, buildLoginCommand, buildStatusCommand, checkCommandVersion, commandExists, createLineParser, debugLog, logProviderSpawn, resolveWindowsCommand, resolveCommandPath, resolveCommandRealPath, runCommand, } from './utils.js';
+import { buildInstallCommandAuto, buildLoginCommand, buildStatusCommand, checkCommandVersion, commandExists, createLineParser, applySystemPrompt, debugLog, logProviderSpawn, resolveWindowsCommand, resolveCommandPath, resolveCommandRealPath, runCommand, } from './utils.js';
 const CODEX_PACKAGE = '@openai/codex';
 const DEFAULT_LOGIN = 'codex login';
 const DEFAULT_STATUS = 'codex login status';
@@ -237,9 +237,7 @@ function buildCodexExecArgs(options) {
     }
     args.push('--yolo');
     const summarySetting = process.env.AGENTCONNECT_CODEX_REASONING_SUMMARY;
-    const summary = summarySetting && summarySetting.trim()
-        ? summarySetting.trim()
-        : 'detailed';
+    const summary = summarySetting && summarySetting.trim() ? summarySetting.trim() : 'detailed';
     const summaryDisabled = ['0', 'false', 'off', 'none'].includes(summary.toLowerCase());
     if (!summaryDisabled) {
         args.push('--config', `model_reasoning_summary=${summary}`);
@@ -329,7 +327,9 @@ export async function getCodexStatus() {
         const status = buildStatusCommand('AGENTCONNECT_CODEX_STATUS', DEFAULT_STATUS);
         if (status.command) {
             const statusCommand = resolveWindowsCommand(status.command);
-            const result = await runCommand(statusCommand, status.args, { env: { ...process.env, CI: '1' } });
+            const result = await runCommand(statusCommand, status.args, {
+                env: { ...process.env, CI: '1' },
+            });
             const output = `${result.stdout}\n${result.stderr}`.toLowerCase();
             if (output.includes('not logged in') ||
                 output.includes('not logged') ||
@@ -430,11 +430,20 @@ function extractUsage(ev) {
     const usage = ev.usage ?? ev.token_usage ?? ev.tokens ?? ev.tokenUsage;
     if (!usage || typeof usage !== 'object')
         return null;
-    const toNumber = (v) => typeof v === 'number' && Number.isFinite(v) ? v : undefined;
+    const toNumber = (v) => {
+        if (typeof v === 'number' && Number.isFinite(v))
+            return v;
+        if (typeof v === 'string' && v.trim()) {
+            const parsed = Number(v);
+            return Number.isFinite(parsed) ? parsed : undefined;
+        }
+        return undefined;
+    };
     const input = toNumber(usage.input_tokens ?? usage.prompt_tokens ?? usage.inputTokens ?? usage.promptTokens);
     const output = toNumber(usage.output_tokens ?? usage.completion_tokens ?? usage.outputTokens ?? usage.completionTokens);
     const total = toNumber(usage.total_tokens ?? usage.totalTokens);
     const cached = toNumber(usage.cached_input_tokens ?? usage.cachedInputTokens);
+    const reasoning = toNumber(usage.reasoning_tokens ?? usage.reasoningTokens);
     const out = {};
     if (input !== undefined)
         out.input_tokens = input;
@@ -444,6 +453,61 @@ function extractUsage(ev) {
         out.total_tokens = total;
     if (cached !== undefined)
         out.cached_input_tokens = cached;
+    if (reasoning !== undefined)
+        out.reasoning_tokens = reasoning;
+    return Object.keys(out).length ? out : null;
+}
+function extractContextUsage(ev, usage) {
+    const context = ev.context_usage ?? ev.contextUsage;
+    const toNumber = (v) => {
+        if (typeof v === 'number' && Number.isFinite(v))
+            return v;
+        if (typeof v === 'string' && v.trim()) {
+            const parsed = Number(v);
+            return Number.isFinite(parsed) ? parsed : undefined;
+        }
+        return undefined;
+    };
+    const toBoolean = (v) => typeof v === 'boolean' ? v : undefined;
+    const contextWindow = toNumber(context?.context_window ?? context?.contextWindow ?? ev.context_window ?? ev.contextWindow);
+    let contextTokens = toNumber(context?.context_tokens ?? context?.contextTokens ?? ev.context_tokens ?? ev.contextTokens);
+    let contextCachedTokens = toNumber(context?.context_cached_tokens ??
+        context?.contextCachedTokens ??
+        ev.context_cached_tokens ??
+        ev.contextCachedTokens);
+    let contextRemainingTokens = toNumber(context?.context_remaining_tokens ??
+        context?.contextRemainingTokens ??
+        ev.context_remaining_tokens ??
+        ev.contextRemainingTokens);
+    const contextTruncated = toBoolean(context?.context_truncated ?? context?.contextTruncated ?? ev.context_truncated ?? ev.contextTruncated);
+    if (contextTokens === undefined) {
+        if (usage?.input_tokens !== undefined &&
+            usage?.cached_input_tokens !== undefined) {
+            contextTokens = usage.input_tokens + usage.cached_input_tokens;
+        }
+        else if (usage?.input_tokens !== undefined) {
+            contextTokens = usage.input_tokens;
+        }
+    }
+    if (contextCachedTokens === undefined && usage?.cached_input_tokens !== undefined) {
+        contextCachedTokens = usage.cached_input_tokens;
+    }
+    if (contextRemainingTokens === undefined &&
+        contextWindow !== undefined &&
+        contextTokens !== undefined) {
+        contextRemainingTokens = Math.max(0, contextWindow - contextTokens);
+    }
+    const out = {};
+    if (contextWindow !== undefined)
+        out.context_window = contextWindow;
+    if (contextTokens !== undefined)
+        out.context_tokens = contextTokens;
+    if (contextCachedTokens !== undefined)
+        out.context_cached_tokens = contextCachedTokens;
+    if (contextRemainingTokens !== undefined)
+        out.context_remaining_tokens = contextRemainingTokens;
+    if (contextTruncated !== undefined)
+        out.context_truncated = contextTruncated;
     return Object.keys(out).length ? out : null;
 }
 function normalizeItem(raw) {
@@ -644,16 +708,17 @@ export async function listCodexModels() {
     // Fetch failed - return empty, don't cache so it retries next time
     return [];
 }
-export function runCodexPrompt({ prompt, resumeSessionId, model, reasoningEffort, repoRoot, cwd, providerDetailLevel, onEvent, signal, }) {
+export function runCodexPrompt({ prompt, system, resumeSessionId, model, reasoningEffort, repoRoot, cwd, providerDetailLevel, onEvent, signal, }) {
     return new Promise((resolve) => {
         const command = getCodexCommand();
         const resolvedRepoRoot = repoRoot ? path.resolve(repoRoot) : null;
         const resolvedCwd = cwd ? path.resolve(cwd) : null;
         const runDir = resolvedCwd || resolvedRepoRoot || process.cwd();
         const cdTarget = resolvedRepoRoot || resolvedCwd || '.';
+        const composedPrompt = applySystemPrompt(system, prompt);
         const runAttempt = (mode) => new Promise((attemptResolve) => {
             const args = buildCodexExecArgs({
-                prompt,
+                prompt: composedPrompt,
                 cdTarget,
                 resumeSessionId,
                 model,
@@ -839,8 +904,16 @@ export function runCodexPrompt({ prompt, resumeSessionId, model, reasoningEffort
                 if (usage) {
                     emit({
                         type: 'usage',
-                        inputTokens: usage.input_tokens,
-                        outputTokens: usage.output_tokens,
+                        usage,
+                        providerDetail,
+                    });
+                    handled = true;
+                }
+                const contextUsage = extractContextUsage(ev, usage);
+                if (contextUsage) {
+                    emit({
+                        type: 'context_usage',
+                        contextUsage,
                         providerDetail,
                     });
                     handled = true;
@@ -893,9 +966,7 @@ export function runCodexPrompt({ prompt, resumeSessionId, model, reasoningEffort
                 }
                 if (isTerminalEvent(ev) && !didFinalize) {
                     if (ev.type === 'turn.failed') {
-                        const message = typeof ev.error?.message === 'string'
-                            ? ev.error.message
-                            : pendingError?.message;
+                        const message = typeof ev.error?.message === 'string' ? ev.error.message : pendingError?.message;
                         emitError(message ?? 'Codex run failed', providerDetail);
                         didFinalize = true;
                         handled = true;
@@ -921,10 +992,9 @@ export function runCodexPrompt({ prompt, resumeSessionId, model, reasoningEffort
                         const hint = stderrLines.at(-1) || stdoutLines.at(-1) || '';
                         const context = pendingError?.message || hint;
                         const suffix = context ? `: ${context}` : '';
-                        const fallback = mode === 'modern' && !sawJson && shouldFallbackToLegacy([
-                            ...stderrLines,
-                            ...stdoutLines,
-                        ]);
+                        const fallback = mode === 'modern' &&
+                            !sawJson &&
+                            shouldFallbackToLegacy([...stderrLines, ...stdoutLines]);
                         debugLog('Codex', 'exit', {
                             code,
                             stderr: stderrLines,

package/dist/providers/cursor.d.ts

@@ -8,4 +8,4 @@ export declare function updateCursor(): Promise<ProviderStatus>;
 export declare function loginCursor(options?: ProviderLoginOptions): Promise<{
     loggedIn: boolean;
 }>;
-export declare function runCursorPrompt({ prompt, resumeSessionId, model, repoRoot, cwd, providerDetailLevel, onEvent, signal, }: RunPromptOptions): Promise<RunPromptResult>;
+export declare function runCursorPrompt({ prompt, system, resumeSessionId, model, repoRoot, cwd, providerDetailLevel, onEvent, signal, }: RunPromptOptions): Promise<RunPromptResult>;

package/dist/providers/cursor.js

@@ -1,6 +1,6 @@
 import { spawn } from 'child_process';
 import path from 'path';
-import { buildInstallCommand, buildLoginCommand, buildStatusCommand, checkCommandVersion, commandExists, createLineParser, debugLog, logProviderSpawn, resolveWindowsCommand, resolveCommandPath, resolveCommandRealPath, runCommand, } from './utils.js';
+import { buildInstallCommand, buildLoginCommand, buildStatusCommand, checkCommandVersion, commandExists, createLineParser, applySystemPrompt, debugLog, logProviderSpawn, resolveWindowsCommand, resolveCommandPath, resolveCommandRealPath, runCommand, } from './utils.js';
 const INSTALL_UNIX = 'curl https://cursor.com/install -fsS | bash';
 const DEFAULT_LOGIN = 'cursor-agent login';
 const DEFAULT_STATUS = 'cursor-agent status';
@@ -468,10 +468,20 @@ function extractUsage(ev) {
     const usage = ev.usage ?? ev.token_usage ?? ev.tokenUsage ?? ev.tokens;
     if (!usage || typeof usage !== 'object')
         return null;
-    const toNumber = (v) => typeof v === 'number' && Number.isFinite(v) ? v : undefined;
+    const toNumber = (v) => {
+        if (typeof v === 'number' && Number.isFinite(v))
+            return v;
+        if (typeof v === 'string' && v.trim()) {
+            const parsed = Number(v);
+            return Number.isFinite(parsed) ? parsed : undefined;
+        }
+        return undefined;
+    };
     const input = toNumber(usage.input_tokens ?? usage.prompt_tokens ?? usage.inputTokens ?? usage.promptTokens);
     const output = toNumber(usage.output_tokens ?? usage.completion_tokens ?? usage.outputTokens ?? usage.completionTokens);
     const total = toNumber(usage.total_tokens ?? usage.totalTokens);
+    const cached = toNumber(usage.cached_input_tokens ?? usage.cachedInputTokens);
+    const reasoning = toNumber(usage.reasoning_tokens ?? usage.reasoningTokens);
     const out = {};
     if (input !== undefined)
         out.input_tokens = input;
@@ -479,6 +489,63 @@ function extractUsage(ev) {
         out.output_tokens = output;
     if (total !== undefined)
         out.total_tokens = total;
+    if (cached !== undefined)
+        out.cached_input_tokens = cached;
+    if (reasoning !== undefined)
+        out.reasoning_tokens = reasoning;
+    return Object.keys(out).length ? out : null;
+}
+function extractContextUsage(ev, usage) {
+    const context = ev.context_usage ?? ev.contextUsage;
+    const toNumber = (v) => {
+        if (typeof v === 'number' && Number.isFinite(v))
+            return v;
+        if (typeof v === 'string' && v.trim()) {
+            const parsed = Number(v);
+            return Number.isFinite(parsed) ? parsed : undefined;
+        }
+        return undefined;
+    };
+    const toBoolean = (v) => typeof v === 'boolean' ? v : undefined;
+    const contextWindow = toNumber(context?.context_window ?? context?.contextWindow ?? ev.context_window ?? ev.contextWindow);
+    let contextTokens = toNumber(context?.context_tokens ?? context?.contextTokens ?? ev.context_tokens ?? ev.contextTokens);
+    let contextCachedTokens = toNumber(context?.context_cached_tokens ??
+        context?.contextCachedTokens ??
+        ev.context_cached_tokens ??
+        ev.contextCachedTokens);
+    let contextRemainingTokens = toNumber(context?.context_remaining_tokens ??
+        context?.contextRemainingTokens ??
+        ev.context_remaining_tokens ??
+        ev.contextRemainingTokens);
+    const contextTruncated = toBoolean(context?.context_truncated ?? context?.contextTruncated ?? ev.context_truncated ?? ev.contextTruncated);
+    if (contextTokens === undefined) {
+        if (usage?.input_tokens !== undefined &&
+            usage?.cached_input_tokens !== undefined) {
+            contextTokens = usage.input_tokens + usage.cached_input_tokens;
+        }
+        else if (usage?.input_tokens !== undefined) {
+            contextTokens = usage.input_tokens;
+        }
+    }
+    if (contextCachedTokens === undefined && usage?.cached_input_tokens !== undefined) {
+        contextCachedTokens = usage.cached_input_tokens;
+    }
+    if (contextRemainingTokens === undefined &&
+        contextWindow !== undefined &&
+        contextTokens !== undefined) {
+        contextRemainingTokens = Math.max(0, contextWindow - contextTokens);
+    }
+    const out = {};
+    if (contextWindow !== undefined)
+        out.context_window = contextWindow;
+    if (contextTokens !== undefined)
+        out.context_tokens = contextTokens;
+    if (contextCachedTokens !== undefined)
+        out.context_cached_tokens = contextCachedTokens;
+    if (contextRemainingTokens !== undefined)
+        out.context_remaining_tokens = contextRemainingTokens;
+    if (contextTruncated !== undefined)
+        out.context_truncated = contextTruncated;
     return Object.keys(out).length ? out : null;
 }
 function extractTextFromContent(content) {
@@ -611,7 +678,7 @@ function extractErrorMessage(ev) {
         return ev.result;
     return null;
 }
-export function runCursorPrompt({ prompt, resumeSessionId, model, repoRoot, cwd, providerDetailLevel, onEvent, signal, }) {
+export function runCursorPrompt({ prompt, system, resumeSessionId, model, repoRoot, cwd, providerDetailLevel, onEvent, signal, }) {
     return new Promise((resolve) => {
         const command = getCursorCommand();
         const resolvedRepoRoot = repoRoot ? path.resolve(repoRoot) : null;
@@ -630,7 +697,8 @@ export function runCursorPrompt({ prompt, resumeSessionId, model, repoRoot, cwd,
         if (endpoint) {
             args.push('--endpoint', endpoint);
         }
-        args.push(prompt);
+        const composedPrompt = applySystemPrompt(system, prompt);
+        args.push(composedPrompt);
         logProviderSpawn({
             provider: 'cursor',
             command,
@@ -650,7 +718,7 @@ export function runCursorPrompt({ prompt, resumeSessionId, model, repoRoot, cwd,
             endpoint: endpoint || null,
             resume: resumeSessionId || null,
             apiKeyConfigured: Boolean(getCursorApiKey().trim()),
-            promptChars: prompt.length,
+            promptChars: composedPrompt.length,
         });
         const child = spawn(command, args, {
             cwd: runDir,
@@ -786,8 +854,14 @@ export function runCursorPrompt({ prompt, resumeSessionId, model, repoRoot, cwd,
             if (usage) {
                 emit({
                     type: 'usage',
-                    inputTokens: usage.input_tokens,
-                    outputTokens: usage.output_tokens,
+                    usage,
+                });
+            }
+            const contextUsage = extractContextUsage(ev, usage);
+            if (contextUsage) {
+                emit({
+                    type: 'context_usage',
+                    contextUsage,
                 });
             }
             if (isErrorEvent(ev)) {

package/dist/providers/local.d.ts

@@ -6,4 +6,4 @@ export declare function loginLocal(options?: ProviderLoginOptions): Promise<{
     loggedIn: boolean;
 }>;
 export declare function listLocalModels(): Promise<ModelInfo[]>;
-export declare function runLocalPrompt({ prompt, model, onEvent, }: RunPromptOptions): Promise<RunPromptResult>;
+export declare function runLocalPrompt({ prompt, system, model, onEvent, }: RunPromptOptions): Promise<RunPromptResult>;

package/dist/providers/local.js

@@ -76,7 +76,7 @@ export async function listLocalModels() {
         .map((entry) => ({ id: entry.id, provider: 'local', displayName: entry.id }))
         .filter((entry) => entry.id);
 }
-export async function runLocalPrompt({ prompt, model, onEvent, }) {
+export async function runLocalPrompt({ prompt, system, model, onEvent, }) {
     const base = getLocalBaseUrl();
     const fallback = process.env.AGENTCONNECT_LOCAL_MODEL || '';
     const resolvedModel = resolveLocalModel(model, fallback);
@@ -90,9 +90,15 @@ export async function runLocalPrompt({ prompt, model, onEvent, }) {
         args: ['--base-url', base, '--model', resolvedModel, prompt],
         cwd: process.cwd(),
     });
+    const messages = [];
+    const systemPrompt = typeof system === 'string' ? system.trim() : '';
+    if (systemPrompt) {
+        messages.push({ role: 'system', content: systemPrompt });
+    }
+    messages.push({ role: 'user', content: prompt });
     const payload = {
         model: resolvedModel,
-        messages: [{ role: 'user', content: prompt }],
+        messages,
         stream: false,
     };
     const headers = { 'Content-Type': 'application/json' };

package/dist/providers/utils.d.ts

@@ -10,6 +10,7 @@ export declare function logProviderSpawn(options: {
     redactIndex?: number;
 }): void;
 export declare function debugLog(scope: string, message: string, details?: Record<string, unknown>): void;
+export declare function applySystemPrompt(system: string | undefined, prompt: string): string;
 export interface SplitCommandResult {
     command: string;
     args: string[];

package/dist/providers/utils.js

@@ -17,9 +17,7 @@ export function logProviderSpawn(options) {
     }
     const cwd = options.cwd || process.cwd();
     const formatted = formatShellCommand(options.command, redacted);
-    const fullCommand = cwd
-        ? `${formatShellCommand('cd', [cwd])} && ${formatted}`
-        : formatted;
+    const fullCommand = cwd ? `${formatShellCommand('cd', [cwd])} && ${formatted}` : formatted;
     console.log(`AgentConnect: ${fullCommand}`);
 }
 function formatShellCommand(command, args) {
@@ -46,6 +44,12 @@ export function debugLog(scope, message, details) {
     }
     console.log(`[AgentConnect][${scope}] ${message}${suffix}`);
 }
+export function applySystemPrompt(system, prompt) {
+    const trimmed = typeof system === 'string' ? system.trim() : '';
+    if (!trimmed)
+        return prompt;
+    return `<<SYSTEM>>\n${trimmed}\n<</SYSTEM>>\n\n<<USER>>\n${prompt}`;
+}
 export function splitCommand(value) {
     if (!value)
         return { command: '', args: [] };

package/dist/summary.d.ts

@@ -1,5 +1,5 @@
 import type { Provider, ProviderId } from './types.js';
-export type SummarySource = 'prompt' | 'claude-log';
+export type SummarySource = 'prompt';
 export type SummaryPayload = {
     summary: string;
     source: SummarySource;
@@ -9,6 +9,7 @@ export type SummaryPayload = {
 };
 export declare function getSummaryModel(providerId: ProviderId): string | null;
 export declare function buildSummaryPrompt(userPrompt: string, reasoning?: string): string;
+export declare function buildSummaryPromptWithOverride(template: string, userPrompt: string, reasoning?: string): string;
 export declare function sanitizeSummary(raw: string): string;
 export declare function runSummaryPrompt(options: {
     provider: Provider;
@@ -21,9 +22,3 @@ export declare function runSummaryPrompt(options: {
     summary: string;
     model?: string | null;
 } | null>;
-export declare function pollClaudeSummary(options: {
-    basePath: string;
-    sessionId: string;
-    timeoutMs?: number;
-    intervalMs?: number;
-}): Promise<string | null>;

package/dist/summary.js

@@ -1,7 +1,3 @@
-import fs from 'fs';
-import { promises as fsp } from 'fs';
-import os from 'os';
-import path from 'path';
 const SUMMARY_MODEL_OVERRIDES = {
     claude: 'haiku',
     codex: 'gpt-5.1-codex-mini',
@@ -30,6 +26,7 @@ export function buildSummaryPrompt(userPrompt, reasoning) {
     const clippedReasoning = reasoning?.trim() ? clipText(reasoning, REASONING_MAX_CHARS) : '';
     const lines = [
         'You write ultra-short task summaries for a chat list.',
+        'Do not run commands or edit files; only write the summary.',
         `Summarize the task in ${Math.max(6, SUMMARY_MAX_WORDS - 4)}-${SUMMARY_MAX_WORDS} words.`,
         'Capture the task and outcome; include key file/component/tech if present.',
         'Use a specific action verb; avoid vague verbs like "help" or "work on".',
@@ -46,8 +43,32 @@ export function buildSummaryPrompt(userPrompt, reasoning) {
     }
     return lines.join('\n');
 }
+export function buildSummaryPromptWithOverride(template, userPrompt, reasoning) {
+    const trimmedTemplate = template.trim();
+    if (!trimmedTemplate)
+        return buildSummaryPrompt(userPrompt, reasoning);
+    const clipped = clipText(userPrompt.trim(), 1200);
+    const clippedReasoning = reasoning?.trim() ? clipText(reasoning, REASONING_MAX_CHARS) : '';
+    const hasMessage = trimmedTemplate.includes('{{message}}');
+    const hasReasoning = trimmedTemplate.includes('{{reasoning}}');
+    let prompt = trimmedTemplate;
+    if (hasMessage)
+        prompt = prompt.replaceAll('{{message}}', clipped);
+    if (hasReasoning)
+        prompt = prompt.replaceAll('{{reasoning}}', clippedReasoning);
+    if (!hasMessage) {
+        prompt = `${prompt}\n\nUser request:\n${clipped}`;
+    }
+    if (clippedReasoning && !hasReasoning) {
+        prompt = `${prompt}\n\nInitial reasoning (first lines):\n${clippedReasoning}`;
+    }
+    return prompt;
+}
 export function sanitizeSummary(raw) {
-    const normalized = raw.replace(/[\r\n]+/g, ' ').replace(/\s+/g, ' ').trim();
+    const normalized = raw
+        .replace(/[\r\n]+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
     const stripped = normalized.replace(/^["']+|["']+$/g, '').trim();
     const cleaned = stripped.replace(/[.!?]+$/g, '').trim();
     if (!cleaned)
@@ -107,72 +128,3 @@ export async function runSummaryPrompt(options) {
     }
     return attempt(null);
 }
-function buildClaudeProjectKey(basePath) {
-    const resolved = path.resolve(basePath);
-    const normalized = resolved.split(path.sep).filter(Boolean).join('-');
-    return `-${normalized}`;
-}
-function resolveClaudeSummaryPath(basePath, sessionId) {
-    if (!sessionId)
-        return null;
-    const root = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
-    const projectKey = buildClaudeProjectKey(basePath);
-    return path.join(root, 'projects', projectKey, `${sessionId}.jsonl`);
-}
-async function readClaudeSummaryFile(filePath) {
-    if (!fs.existsSync(filePath))
-        return null;
-    try {
-        const raw = await fsp.readFile(filePath, 'utf8');
-        let latest = null;
-        for (const line of raw.split(/\r?\n/)) {
-            if (!line.trim())
-                continue;
-            let parsed;
-            try {
-                parsed = JSON.parse(line);
-            }
-            catch {
-                continue;
-            }
-            if (!parsed || typeof parsed !== 'object')
-                continue;
-            const record = parsed;
-            if (record.type !== 'summary')
-                continue;
-            const summary = record.summary;
-            if (typeof summary === 'string' && summary.trim()) {
-                latest = summary.trim();
-            }
-        }
-        return latest ? sanitizeSummary(latest) : null;
-    }
-    catch {
-        return null;
-    }
-}
-export async function pollClaudeSummary(options) {
-    const { basePath, sessionId, timeoutMs = 30000, intervalMs = 1500 } = options;
-    const filePath = resolveClaudeSummaryPath(basePath, sessionId);
-    if (!filePath)
-        return null;
-    const start = Date.now();
-    let lastMtime = 0;
-    while (Date.now() - start < timeoutMs) {
-        try {
-            const stat = await fsp.stat(filePath);
-            const mtime = stat.mtimeMs;
-            if (mtime !== lastMtime) {
-                lastMtime = mtime;
-                const summary = await readClaudeSummaryFile(filePath);
-                if (summary)
-                    return summary;
-            }
-        }
-        catch {
-            // ignore
-        }
-        await new Promise((resolve) => setTimeout(resolve, intervalMs));
-    }
-    return null;
-}

package/dist/types.d.ts

@@ -116,6 +116,20 @@ export interface ModelInfo {
     reasoningEfforts?: ReasoningEffort[];
     defaultReasoningEffort?: string;
 }
+export type TokenUsage = {
+    input_tokens?: number;
+    output_tokens?: number;
+    total_tokens?: number;
+    cached_input_tokens?: number;
+    reasoning_tokens?: number;
+};
+export type ContextUsage = {
+    context_window?: number;
+    context_tokens?: number;
+    context_cached_tokens?: number;
+    context_remaining_tokens?: number;
+    context_truncated?: boolean;
+};
 export interface ProviderLoginOptions {
     baseUrl?: string;
     apiKey?: string;
@@ -125,15 +139,15 @@ export interface ProviderLoginOptions {
     loginExperience?: 'embedded' | 'terminal';
 }
 export interface SessionEvent {
-    type: 'delta' | 'final' | 'usage' | 'status' | 'error' | 'raw_line' | 'message' | 'thinking' | 'tool_call' | 'detail' | 'summary';
+    type: 'delta' | 'final' | 'usage' | 'context_usage' | 'status' | 'error' | 'raw_line' | 'message' | 'thinking' | 'tool_call' | 'detail' | 'summary';
     text?: string;
     message?: string;
     line?: string;
     provider?: ProviderId;
     providerDetail?: ProviderDetail;
     providerSessionId?: string | null;
-    inputTokens?: number;
-    outputTokens?: number;
+    usage?: TokenUsage;
+    contextUsage?: ContextUsage;
     role?: 'system' | 'user' | 'assistant';
     content?: string;
     contentParts?: unknown;
@@ -146,12 +160,13 @@ export interface SessionEvent {
     timestampMs?: number;
     cancelled?: boolean;
     summary?: string;
-    source?: 'prompt' | 'claude-log';
+    source?: 'prompt';
     model?: string | null;
     createdAt?: string;
 }
 export interface RunPromptOptions {
     prompt: string;
+    system?: string;
     resumeSessionId?: string | null;
     model?: string;
     reasoningEffort?: string | null;
@@ -193,12 +208,17 @@ export interface SessionState {
     cwd?: string;
     repoRoot?: string;
     providerDetailLevel?: ProviderDetailLevel;
+    systemPrompt?: string;
+    summaryMode?: 'auto' | 'off';
+    summaryPrompt?: string;
+    summaryNextMode?: 'auto' | 'off' | 'force';
+    summaryNextPrompt?: string;
+    summaryAutoUsed?: boolean;
     summaryRequested?: boolean;
-    claudeSummaryWatch?: boolean;
     summarySeed?: string;
     summaryReasoning?: string;
     summary?: string | null;
-    summarySource?: 'prompt' | 'claude-log';
+    summarySource?: 'prompt';
     summaryModel?: string | null;
     summaryCreatedAt?: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentconnect/host",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "license": "MIT",
   "type": "module",
   "homepage": "https://github.com/rayzhudev/agent-connect",