@pellux/goodvibes-sdk 0.18.13 → 0.18.15

package/dist/_internal/platform/runtime/session-maintenance.js

@@ -0,0 +1,148 @@
+export function getGuidanceMode(configManager) {
+    return configManager.get('behavior.guidanceMode') ?? 'minimal';
+}
+function compactStateIsActive(state) {
+    return state === 'checking_threshold'
+        || state === 'microcompact'
+        || state === 'collapse'
+        || state === 'autocompact'
+        || state === 'reactive_compact'
+        || state === 'boundary_commit';
+}
+function formatAge(ts) {
+    if (!ts)
+        return 'never';
+    const ageMs = Date.now() - ts;
+    const minutes = Math.floor(ageMs / 60_000);
+    if (minutes < 1)
+        return 'just now';
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    return `${Math.floor(hours / 24)}d ago`;
+}
+export function evaluateSessionMaintenance(input) {
+    const guidanceMode = getGuidanceMode(input.configManager);
+    const thresholdPct = Math.max(0, Number(input.configManager.get('behavior.autoCompactThreshold') ?? 0));
+    const autoCompactEnabled = thresholdPct > 0;
+    const currentTokens = Math.max(0, input.currentTokens);
+    const contextWindow = Math.max(0, input.contextWindow);
+    const usagePct = contextWindow > 0 ? Math.min(100, Math.round((currentTokens / contextWindow) * 100)) : 0;
+    const remainingTokens = Math.max(0, contextWindow - currentTokens);
+    const sessionMemoryCount = Math.max(0, input.sessionMemoryCount ?? 0);
+    const compactionCount = Math.max(0, input.session?.lineage?.filter((entry) => entry.branchReason === 'compaction').length ?? 0);
+    const lastCompactedAt = input.session?.lastCompactedAt;
+    const messageCount = Math.max(0, input.messageCount ?? 0);
+    const warningsEnabled = Boolean(input.configManager.get('behavior.staleContextWarnings'));
+    const staleByMessageGrowth = (input.session?.compactionMessageCount ?? 0) > 0
+        ? messageCount - (input.session?.compactionMessageCount ?? 0) >= 12
+        : messageCount >= 24;
+    if (contextWindow <= 0) {
+        return {
+            level: 'unknown',
+            guidanceMode,
+            usagePct,
+            remainingTokens,
+            thresholdPct,
+            autoCompactEnabled,
+            compactRecommended: false,
+            sessionMemoryCount,
+            compactionCount,
+            lastCompactedAt,
+            summary: 'Context window unavailable.',
+            reasons: ['Current model does not expose a known context limit yet.'],
+            nextSteps: guidanceMode === 'off' ? [] : ['/provider', '/context'],
+        };
+    }
+    const reasons = [];
+    const nextSteps = [];
+    let level = 'stable';
+    if (input.session?.compactionState === 'failed') {
+        level = 'needs-repair';
+        reasons.push('Compaction failed and the session may need manual recovery.');
+        nextSteps.push('/compact', '/health review');
+    }
+    else if (compactStateIsActive(input.session?.compactionState)) {
+        level = 'compacting';
+        reasons.push('Compaction is currently running.');
+    }
+    else if ((autoCompactEnabled && usagePct >= thresholdPct) || usagePct >= 80 || remainingTokens <= 15_000) {
+        level = 'suggest-compact';
+        reasons.push(`Context pressure is high at ${usagePct}% usage.`);
+        if (remainingTokens <= 15_000) {
+            reasons.push(`Only ${remainingTokens.toLocaleString()} tokens remain before the safety buffer is exhausted.`);
+        }
+        nextSteps.push('/compact', '/panel tokens');
+    }
+    else if ((warningsEnabled && usagePct >= Math.max(70, autoCompactEnabled ? thresholdPct - 10 : 70)) || staleByMessageGrowth) {
+        level = 'watch';
+        reasons.push(staleByMessageGrowth
+            ? `Conversation has grown ${messageCount.toLocaleString()} messages since the last maintenance checkpoint.`
+            : `Context usage is climbing toward the ${thresholdPct}% auto-compact threshold.`);
+        nextSteps.push('/panel tokens');
+        if (guidanceMode === 'guided')
+            nextSteps.push('/context');
+    }
+    else {
+        reasons.push('Context pressure is currently within the stable operating band.');
+    }
+    if (sessionMemoryCount > 0) {
+        reasons.push(`${sessionMemoryCount} pinned session memor${sessionMemoryCount === 1 ? 'y is' : 'ies are'} preserved during compaction.`);
+    }
+    if (compactionCount > 0) {
+        reasons.push(`Last compaction ran ${formatAge(lastCompactedAt)}.`);
+    }
+    if (!autoCompactEnabled) {
+        reasons.push('Auto-compaction is disabled; maintenance stays fully manual.');
+        if (guidanceMode !== 'off')
+            nextSteps.push('/settings');
+    }
+    const compactRecommended = level === 'suggest-compact' || level === 'needs-repair';
+    const summary = level === 'needs-repair'
+        ? 'Compaction needs operator repair.'
+        : level === 'compacting'
+            ? 'Compaction in progress.'
+            : level === 'suggest-compact'
+                ? `Compact now to recover context headroom (${usagePct}% used).`
+                : level === 'watch'
+                    ? `Watch context growth (${usagePct}% used, threshold ${thresholdPct}%).`
+                    : 'Session maintenance is stable.';
+    return {
+        level,
+        guidanceMode,
+        usagePct,
+        remainingTokens,
+        thresholdPct,
+        autoCompactEnabled,
+        compactRecommended,
+        sessionMemoryCount,
+        compactionCount,
+        lastCompactedAt,
+        summary,
+        reasons,
+        nextSteps: [...new Set(nextSteps)],
+    };
+}
+export function formatSessionMaintenanceLines(status, detail = 'minimal') {
+    const lines = [
+        `Maintenance: ${status.summary}`,
+    ];
+    if (detail === 'guided') {
+        for (const reason of status.reasons)
+            lines.push(`  ${reason}`);
+    }
+    else if (status.reasons[0]) {
+        lines.push(`  ${status.reasons[0]}`);
+    }
+    const nextSteps = status.nextSteps.length > 0
+        ? status.nextSteps
+        : detail === 'guided'
+            ? ['/context']
+            : [];
+    if ((detail === 'guided' || status.guidanceMode !== 'off') && nextSteps.length > 0) {
+        lines.push(`  Next: ${nextSteps.join('  |  ')}`);
+    }
+    return lines;
+}

package/dist/_internal/platform/runtime/session-persistence.d.ts

@@ -0,0 +1,39 @@
+import { SessionManager } from '../sessions/manager.js';
+import type { SessionReturnContextSummary } from './session-return-context.js';
+import type { ConversationTitleSource } from '../core/conversation.js';
+export type SessionSnapshot = {
+    messages: Array<Record<string, unknown>>;
+    timestamp?: number;
+    title?: string;
+    titleSource?: ConversationTitleSource;
+    returnContext?: SessionReturnContextSummary;
+};
+export type RecoveryFileInfo = {
+    title: string;
+    timestamp: number;
+    sessionId: string;
+    returnContext?: SessionReturnContextSummary;
+};
+export type SessionPersistenceOptions = {
+    workingDirectory?: string;
+    homeDirectory?: string;
+    sessionManager?: SessionManager;
+};
+export type SessionPersistencePaths = {
+    readonly workingDirectory: string;
+    readonly homeDirectory: string;
+};
+export declare function getUserSessionsDir(workingDirectory: string): string;
+export declare function getLastSessionPointerPath(workingDirectory: string): string;
+export declare function getRecoveryFilePath(homeDirectory: string): string;
+export declare function generateUserSessionId(): string;
+export declare function saveSession(sessionId: string, data: SessionSnapshot, model: string, provider: string, title?: string, options?: SessionPersistenceOptions): void;
+export declare function persistConversation(sessionId: string, data: SessionSnapshot, model: string, provider: string, title?: string, options?: SessionPersistenceOptions): void;
+export declare function writeLastSessionPointer(sessionId: string, options?: SessionPersistenceOptions): void;
+export declare function readLastSessionPointer(options?: SessionPersistenceOptions): string | null;
+export declare function loadLastConversation(options?: SessionPersistenceOptions): SessionSnapshot | null;
+export declare function writeRecoveryFile(snapshot: SessionSnapshot, sessionId: string, title?: string, options?: SessionPersistenceOptions): void;
+export declare function deleteRecoveryFile(options?: SessionPersistenceOptions): void;
+export declare function checkRecoveryFile(options?: SessionPersistenceOptions): RecoveryFileInfo | null;
+export declare function loadRecoveryConversation(options?: SessionPersistenceOptions): SessionSnapshot | null;
+//# sourceMappingURL=session-persistence.d.ts.map

package/dist/_internal/platform/runtime/session-persistence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-persistence.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/runtime/session-persistence.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,cAAc,EAAoB,MAAM,wBAAwB,CAAC;AAE1E,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,6BAA6B,CAAC;AAC/E,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAKvE,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACzC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,uBAAuB,CAAC;IACtC,aAAa,CAAC,EAAE,2BAA2B,CAAC;CAC7C,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,2BAA2B,CAAC;CAC7C,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC,CAAC;AAgCF,wBAAgB,kBAAkB,CAAC,gBAAgB,EAAE,MAAM,GAAG,MAAM,CAEnE;AAED,wBAAgB,yBAAyB,CAAC,gBAAgB,EAAE,MAAM,GAAG,MAAM,CAE1E;AAED,wBAAgB,mBAAmB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAEjE;AAED,wBAAgB,qBAAqB,IAAI,MAAM,CAE9C;AAED,wBAAgB,WAAW,CACzB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,eAAe,EACrB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,KAAK,SAAK,EACV,OAAO,CAAC,EAAE,yBAAyB,GAClC,IAAI,CAeN;AAED,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,eAAe,EACrB,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,KAAK,SAAK,EACV,OAAO,CAAC,EAAE,yBAAyB,GAClC,IAAI,CAGN;AAED,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,yBAAyB,GAAG,IAAI,CAapG;AAED,wBAAgB,sBAAsB,CAAC,OAAO,CAAC,EAAE,yBAAyB,GAAG,MAAM,GAAG,IAAI,CAWzF;AAED,wBAAgB,oBAAoB,CAAC,OAAO,CAAC,EAAE,yBAAyB,GAAG,eAAe,GAAG,IAAI,CAYhG;AAED,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,eAAe,EACzB,SAAS,EAAE,MAAM,EACjB,KAAK,SAAK,EACV,OAAO,CAAC,EAAE,yBAAyB,GAClC,IAAI,CA2BN;AAED,wBAAgB,kBAAkB,CAAC,OAAO,CAAC,EAAE,yBAAyB,GAAG,IAAI,CAO5E;AAED,wBAAgB,iBAAiB,CAAC,OAAO,CAAC,EAAE,yBAAyB,GAAG,gBAAgB,GAAG,IAAI,CAmC9F;AAED,wBAAgB,wBAAwB,CAAC,OAAO,CAAC,EAAE,yBAAyB,GAAG,eAAe,GAAG,IAAI,CA6CpG"}

package/dist/_internal/platform/runtime/session-persistence.js

@@ -0,0 +1,226 @@
+import { randomBytes } from 'crypto';
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, renameSync, statSync, unlinkSync, writeFileSync, } from 'fs';
+import { dirname, join } from 'path';
+import { SessionManager } from '../sessions/manager.js';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+const SESSION_ROOT = 'goodvibes';
+function requireWorkingDirectory(options) {
+    const workingDirectory = options?.workingDirectory;
+    if (!workingDirectory) {
+        throw new Error('Session persistence requires an explicit workingDirectory.');
+    }
+    return workingDirectory;
+}
+function requireHomeDirectory(options) {
+    const homeDirectory = options?.homeDirectory;
+    if (!homeDirectory) {
+        throw new Error('Session persistence requires an explicit homeDirectory.');
+    }
+    return homeDirectory;
+}
+function resolveSessionPersistencePaths(options) {
+    return {
+        workingDirectory: requireWorkingDirectory(options),
+        homeDirectory: requireHomeDirectory(options),
+    };
+}
+function resolveSessionManager(options) {
+    if (options?.sessionManager) {
+        return options.sessionManager;
+    }
+    return new SessionManager(requireWorkingDirectory(options));
+}
+export function getUserSessionsDir(workingDirectory) {
+    return join(workingDirectory, '.goodvibes', SESSION_ROOT, 'sessions');
+}
+export function getLastSessionPointerPath(workingDirectory) {
+    return join(getUserSessionsDir(workingDirectory), 'last-session.json');
+}
+export function getRecoveryFilePath(homeDirectory) {
+    return join(homeDirectory, '.goodvibes', SESSION_ROOT, 'recovery.jsonl');
+}
+export function generateUserSessionId() {
+    return randomBytes(4).toString('hex');
+}
+export function saveSession(sessionId, data, model, provider, title = '', options) {
+    try {
+        const manager = resolveSessionManager(options);
+        const meta = {
+            title,
+            model,
+            provider,
+            timestamp: data.timestamp ?? Date.now(),
+            titleSource: data.titleSource,
+            returnContext: data.returnContext,
+        };
+        manager.save(sessionId, data.messages, meta);
+    }
+    catch (error) {
+        logger.debug('saveSession failed', { error: summarizeError(error) });
+    }
+}
+export function persistConversation(sessionId, data, model, provider, title = '', options) {
+    saveSession(sessionId, data, model, provider, title, options);
+    writeLastSessionPointer(sessionId, options);
+}
+export function writeLastSessionPointer(sessionId, options) {
+    try {
+        const workingDirectory = requireWorkingDirectory(options);
+        const pointerPath = getLastSessionPointerPath(workingDirectory);
+        mkdirSync(dirname(pointerPath), { recursive: true });
+        writeFileSync(pointerPath, JSON.stringify({ sessionId, timestamp: new Date().toISOString() }) + '\n', 'utf-8');
+    }
+    catch (error) {
+        logger.debug('writeLastSessionPointer failed', { error: summarizeError(error) });
+    }
+}
+export function readLastSessionPointer(options) {
+    try {
+        const workingDirectory = requireWorkingDirectory(options);
+        const pointerPath = getLastSessionPointerPath(workingDirectory);
+        if (!existsSync(pointerPath))
+            return null;
+        const data = JSON.parse(readFileSync(pointerPath, 'utf-8'));
+        if (typeof data.sessionId === 'string' && data.sessionId.trim())
+            return data.sessionId;
+    }
+    catch (error) {
+        logger.debug('readLastSessionPointer failed', { error: summarizeError(error) });
+    }
+    return null;
+}
+export function loadLastConversation(options) {
+    try {
+        const lastId = readLastSessionPointer(options);
+        const manager = resolveSessionManager(options);
+        if (!lastId)
+            return null;
+        const { messages } = manager.load(lastId);
+        return { messages: messages };
+    }
+    catch (error) {
+        logger.debug('loadLastConversation failed', { error: summarizeError(error) });
+    }
+    return null;
+}
+export function writeRecoveryFile(snapshot, sessionId, title = '', options) {
+    try {
+        if (!snapshot.messages.length)
+            return;
+        const homeDirectory = requireHomeDirectory(options);
+        const recoveryFile = getRecoveryFilePath(homeDirectory);
+        const lines = [];
+        lines.push(JSON.stringify({ type: 'meta', sessionId, title, timestamp: Date.now() }));
+        if (snapshot.titleSource || snapshot.returnContext) {
+            lines[0] = JSON.stringify({
+                type: 'meta',
+                sessionId,
+                title,
+                timestamp: Date.now(),
+                titleSource: snapshot.titleSource,
+                returnContext: snapshot.returnContext,
+            });
+        }
+        for (const message of snapshot.messages) {
+            lines.push(JSON.stringify({ type: 'message', ...message }));
+        }
+        const tmpPath = recoveryFile + '.tmp';
+        mkdirSync(dirname(recoveryFile), { recursive: true });
+        writeFileSync(tmpPath, lines.join('\n') + '\n', 'utf-8');
+        renameSync(tmpPath, recoveryFile);
+    }
+    catch (error) {
+        logger.debug('[Recovery] Write failed', { error: summarizeError(error) });
+    }
+}
+export function deleteRecoveryFile(options) {
+    try {
+        const homeDirectory = requireHomeDirectory(options);
+        unlinkSync(getRecoveryFilePath(homeDirectory));
+    }
+    catch {
+        // missing file is fine
+    }
+}
+export function checkRecoveryFile(options) {
+    try {
+        const { workingDirectory, homeDirectory } = resolveSessionPersistencePaths({
+            workingDirectory: requireWorkingDirectory(options),
+            homeDirectory: requireHomeDirectory(options),
+        });
+        const recoveryFile = getRecoveryFilePath(homeDirectory);
+        if (!existsSync(recoveryFile))
+            return null;
+        const recoveryMtime = statSync(recoveryFile).mtimeMs;
+        const pointerPath = getLastSessionPointerPath(workingDirectory);
+        if (existsSync(pointerPath)) {
+            const lastCleanMtime = statSync(pointerPath).mtimeMs;
+            if (recoveryMtime <= lastCleanMtime)
+                return null;
+        }
+        const fd = openSync(recoveryFile, 'r');
+        const buf = Buffer.alloc(4096);
+        const bytesRead = readSync(fd, buf, 0, 4096, 0);
+        closeSync(fd);
+        const firstLine = buf.toString('utf-8', 0, bytesRead).split('\n')[0];
+        const meta = JSON.parse(firstLine);
+        return {
+            title: meta.title ?? '',
+            timestamp: meta.timestamp ?? 0,
+            sessionId: meta.sessionId ?? '',
+            returnContext: meta.returnContext,
+        };
+    }
+    catch (error) {
+        logger.debug('[Recovery] Check failed', { error: summarizeError(error) });
+        return null;
+    }
+}
+export function loadRecoveryConversation(options) {
+    try {
+        const homeDirectory = requireHomeDirectory(options);
+        const recoveryFile = getRecoveryFilePath(homeDirectory);
+        const raw = readFileSync(recoveryFile, 'utf-8');
+        const lines = raw.split('\n').filter(Boolean);
+        if (lines.length < 2)
+            return { messages: [] };
+        return {
+            title: (() => {
+                try {
+                    const metaLine = JSON.parse(lines[0]);
+                    return metaLine.title;
+                }
+                catch {
+                    return undefined;
+                }
+            })(),
+            titleSource: (() => {
+                try {
+                    const metaLine = JSON.parse(lines[0]);
+                    return metaLine.titleSource;
+                }
+                catch {
+                    return undefined;
+                }
+            })(),
+            returnContext: (() => {
+                try {
+                    const metaLine = JSON.parse(lines[0]);
+                    return metaLine.returnContext;
+                }
+                catch {
+                    return undefined;
+                }
+            })(),
+            messages: lines.slice(1).map((line) => {
+                const { type: _type, ...rest } = JSON.parse(line);
+                return rest;
+            }),
+        };
+    }
+    catch (error) {
+        logger.debug('[Recovery] Load failed', { error: summarizeError(error) });
+        return null;
+    }
+}

package/dist/_internal/platform/runtime/session-return-context.d.ts

@@ -0,0 +1,47 @@
+import type { ConversationMessageSnapshot, ConversationTitleSource } from '../core/conversation.js';
+import type { HelperModel } from '../config/helper-model.js';
+import type { ConfigManager } from '../config/manager.js';
+export type ReturnContextMode = 'off' | 'local' | 'assisted';
+export interface SessionContinuityHints {
+    readonly pendingApprovals?: number;
+    readonly activeTasks?: number;
+    readonly blockedTasks?: number;
+    readonly remoteContracts?: number;
+    readonly remoteRunners?: readonly string[];
+    readonly worktreeCount?: number;
+    readonly worktreePaths?: readonly string[];
+    readonly openPanels?: readonly string[];
+}
+export interface SessionReturnContextSummary {
+    readonly activityLabel: string;
+    readonly statusLabel: string;
+    readonly lastUserPrompt?: string;
+    readonly lastAssistantReply?: string;
+    readonly pendingApprovals: number;
+    readonly toolCallCount: number;
+    readonly toolResultCount: number;
+    readonly assistantTurnCount: number;
+    readonly userTurnCount: number;
+    readonly lastRole?: string;
+    readonly activeTasks?: number;
+    readonly blockedTasks?: number;
+    readonly remoteContracts?: number;
+    readonly remoteRunners?: readonly string[];
+    readonly worktreeCount?: number;
+    readonly worktreePaths?: readonly string[];
+    readonly openPanels?: readonly string[];
+    readonly lines: readonly string[];
+    readonly assistedNarrative?: string;
+}
+export interface PersistedSessionContext {
+    readonly titleSource?: ConversationTitleSource;
+    readonly returnContext?: SessionReturnContextSummary;
+}
+type ReturnContextConfig = Pick<ConfigManager, 'get'>;
+export declare function buildPersistedSessionContext(messages: readonly ConversationMessageSnapshot[], titleSource?: ConversationTitleSource, hints?: SessionContinuityHints): PersistedSessionContext;
+export declare function getReturnContextMode(configManager: ReturnContextConfig): ReturnContextMode;
+export declare function buildLocalReturnContextSummary(messages: readonly ConversationMessageSnapshot[], hints?: SessionContinuityHints): SessionReturnContextSummary;
+export declare function maybeAssistReturnContextSummary(configManager: ReturnContextConfig, helperModel: Pick<HelperModel, 'chat'>, summary: SessionReturnContextSummary): Promise<SessionReturnContextSummary>;
+export declare function formatReturnContextForDisplay(summary: SessionReturnContextSummary | undefined): string[];
+export {};
+//# sourceMappingURL=session-return-context.d.ts.map

package/dist/_internal/platform/runtime/session-return-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-return-context.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/runtime/session-return-context.ts"],"names":[],"mappings":"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"}

package/dist/_internal/platform/runtime/session-return-context.js

@@ -0,0 +1,139 @@
+export function buildPersistedSessionContext(messages, titleSource, hints) {
+    return {
+        titleSource,
+        returnContext: buildLocalReturnContextSummary(messages, hints),
+    };
+}
+function truncate(text, max) {
+    return text.length <= max ? text : `${text.slice(0, Math.max(0, max - 1)).trimEnd()}…`;
+}
+function textContent(message) {
+    if (!message)
+        return '';
+    if (typeof message.content === 'string')
+        return message.content;
+    if (!Array.isArray(message.content))
+        return '';
+    return message.content
+        .filter((part) => part.type === 'text')
+        .map((part) => part.text)
+        .join(' ');
+}
+export function getReturnContextMode(configManager) {
+    return configManager.get('behavior.returnContextMode') ?? 'off';
+}
+export function buildLocalReturnContextSummary(messages, hints) {
+    const userMessages = messages.filter((message) => message.role === 'user');
+    const assistantMessages = messages.filter((message) => message.role === 'assistant');
+    const toolMessages = messages.filter((message) => message.role === 'tool');
+    const pendingApprovals = hints?.pendingApprovals
+        ?? messages.filter((message) => message.role === 'system' && typeof message.content === 'string' && /approval/i.test(message.content)).length;
+    const lastUser = [...messages].reverse().find((message) => message.role === 'user');
+    const lastAssistant = [...messages].reverse().find((message) => message.role === 'assistant');
+    const lastMessage = messages[messages.length - 1];
+    const lastUserPrompt = truncate(textContent(lastUser), 120);
+    const lastAssistantReply = truncate(textContent(lastAssistant), 120);
+    let activityLabel = 'Fresh session';
+    let statusLabel = 'idle';
+    if (lastMessage?.role === 'assistant') {
+        activityLabel = 'assistant replied';
+        statusLabel = 'ready for next turn';
+    }
+    else if (lastMessage?.role === 'tool') {
+        activityLabel = 'tool work completed';
+        statusLabel = 'awaiting assistant follow-up';
+    }
+    else if (lastMessage?.role === 'user') {
+        activityLabel = 'user prompt queued';
+        statusLabel = 'awaiting response';
+    }
+    else if (lastMessage?.role === 'system') {
+        activityLabel = 'system/operator update';
+        statusLabel = 'review recommended';
+    }
+    const lines = [];
+    lines.push(`Activity: ${activityLabel}`);
+    lines.push(`Status: ${statusLabel}`);
+    if (lastUserPrompt)
+        lines.push(`Last prompt: ${lastUserPrompt}`);
+    if (lastAssistantReply)
+        lines.push(`Last reply: ${lastAssistantReply}`);
+    if (pendingApprovals > 0)
+        lines.push(`Pending approvals spotted: ${pendingApprovals}`);
+    if (toolMessages.length > 0)
+        lines.push(`Tool results in session: ${toolMessages.length}`);
+    if ((hints?.activeTasks ?? 0) > 0 || (hints?.blockedTasks ?? 0) > 0) {
+        lines.push(`Tasks: active ${hints?.activeTasks ?? 0}, blocked ${hints?.blockedTasks ?? 0}`);
+    }
+    if ((hints?.remoteContracts ?? 0) > 0) {
+        lines.push(`Remote contracts: ${hints?.remoteContracts}`);
+    }
+    if ((hints?.remoteRunners?.length ?? 0) > 0) {
+        lines.push(`Remote runners: ${hints.remoteRunners.slice(0, 3).join(', ')}`);
+    }
+    if ((hints?.worktreeCount ?? 0) > 0) {
+        lines.push(`Worktrees tracked: ${hints?.worktreeCount}`);
+    }
+    if ((hints?.worktreePaths?.length ?? 0) > 0) {
+        lines.push(`Worktree paths: ${hints.worktreePaths.slice(0, 2).join(', ')}`);
+    }
+    if ((hints?.openPanels?.length ?? 0) > 0) {
+        lines.push(`Open panels: ${hints.openPanels.slice(0, 4).join(', ')}`);
+    }
+    return {
+        activityLabel,
+        statusLabel,
+        lastUserPrompt: lastUserPrompt || undefined,
+        lastAssistantReply: lastAssistantReply || undefined,
+        pendingApprovals,
+        toolCallCount: assistantMessages.reduce((count, message) => count + (message.toolCalls?.length ?? 0), 0),
+        toolResultCount: toolMessages.length,
+        assistantTurnCount: assistantMessages.length,
+        userTurnCount: userMessages.length,
+        lastRole: lastMessage?.role,
+        ...(typeof hints?.activeTasks === 'number' ? { activeTasks: hints.activeTasks } : {}),
+        ...(typeof hints?.blockedTasks === 'number' ? { blockedTasks: hints.blockedTasks } : {}),
+        ...(typeof hints?.remoteContracts === 'number' ? { remoteContracts: hints.remoteContracts } : {}),
+        ...(hints?.remoteRunners ? { remoteRunners: [...hints.remoteRunners] } : {}),
+        ...(typeof hints?.worktreeCount === 'number' ? { worktreeCount: hints.worktreeCount } : {}),
+        ...(hints?.worktreePaths ? { worktreePaths: [...hints.worktreePaths] } : {}),
+        ...(hints?.openPanels ? { openPanels: [...hints.openPanels] } : {}),
+        lines,
+    };
+}
+export async function maybeAssistReturnContextSummary(configManager, helperModel, summary) {
+    if (getReturnContextMode(configManager) !== 'assisted')
+        return summary;
+    const enabled = configManager.get('helper.enabled');
+    if (!enabled)
+        return summary;
+    const prompt = [
+        'You are generating a terse resume summary for a terminal coding session.',
+        'Return one sentence under 160 characters.',
+        'Focus on what the operator should look at first.',
+        '',
+        `Activity: ${summary.activityLabel}`,
+        `Status: ${summary.statusLabel}`,
+        ...(summary.lastUserPrompt ? [`Last prompt: ${summary.lastUserPrompt}`] : []),
+        ...(summary.lastAssistantReply ? [`Last reply: ${summary.lastAssistantReply}`] : []),
+        `Pending approvals: ${summary.pendingApprovals}`,
+        `Tool calls: ${summary.toolCallCount}`,
+        `Tool results: ${summary.toolResultCount}`,
+    ].join('\n');
+    const response = (await helperModel.chat('tool_summarize', prompt, { maxTokens: 80, helperOnly: true })).trim();
+    if (!response)
+        return summary;
+    return {
+        ...summary,
+        assistedNarrative: truncate(response.replace(/\s+/g, ' '), 160),
+    };
+}
+export function formatReturnContextForDisplay(summary) {
+    if (!summary)
+        return [];
+    const lines = [...summary.lines];
+    if (summary.assistedNarrative) {
+        lines.unshift(`Assist: ${summary.assistedNarrative}`);
+    }
+    return lines;
+}