@agent-link/agent 0.1.326 → 0.1.329

package/dist/yeaft.js

@@ -0,0 +1,1334 @@
+/**
+ * Yeaft CLI process driver for AgentLink.
+ *
+ * MVP integration:
+ * - Each conversation owns one `yeaft --input-format stream-json --output-format stream-json` process
+ * - User turns are written to stdin as JSONL prompt messages
+ * - Yeaft session ids are generated with the required `session_...` shape
+ * - JSONL stdout is translated into backend_event messages
+ * - Session history is read best-effort from ~/.yeaft/sessions and <workDir>/.yeaft/sessions
+ */
+import { spawn } from 'child_process';
+import { createInterface } from 'readline';
+import { readdirSync, readFileSync, writeFileSync, existsSync, rmSync, mkdirSync, realpathSync, statSync } from 'fs';
+import { dirname, join, resolve } from 'path';
+import { homedir, platform } from 'os';
+import { randomBytes } from 'crypto';
+import { CONFIG_DIR } from './config.js';
+import { getCleanEnv, resetCachedExecutablePath, resolveExecutablePath } from './sdk.js';
+import { getProvider, resolveProviderCommand } from './providers.js';
+import { yeaftCapabilities } from './backends/types.js';
+const conversations = new Map();
+const sendFns = new Set();
+const MODEL_PATTERN = /^[a-zA-Z0-9._:/-]+$/;
+const EFFORT_PATTERN = /^[a-zA-Z0-9._-]+$/;
+const VP_ID_PATTERN = /^[a-zA-Z0-9._-]+$/;
+const SESSION_ID_PATTERN = /^session_[A-Za-z0-9][A-Za-z0-9._-]*$/;
+const TURN_HEARTBEAT_INTERVAL_MS = 15_000;
+const YEAFT_SESSION_LIST_LIMIT = 150;
+const YEAFT_TITLES_FILE = join(CONFIG_DIR, 'yeaft-session-titles.json');
+function generateTurnId() {
+    return `turn_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+}
+function generateYeaftSessionId(conversationId) {
+    const slug = (conversationId || 'web')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 24) || 'web';
+    return `session_agentlink_${slug}_${randomBytes(5).toString('hex')}`;
+}
+function validYeaftSessionId(value) {
+    return typeof value === 'string' && SESSION_ID_PATTERN.test(value) && value.length <= 128;
+}
+function sendFn(msg) {
+    for (const fn of sendFns) {
+        try {
+            fn(msg);
+        }
+        catch { /* ignore */ }
+    }
+}
+export function addYeaftSendFn(fn) {
+    sendFns.add(fn);
+    return () => { sendFns.delete(fn); };
+}
+function sessionRef(sessionId) {
+    return {
+        backendType: 'yeaft',
+        backendSessionId: sessionId,
+        backendThreadId: sessionId,
+        providerSessionId: sessionId || null,
+    };
+}
+function startYeaftTurn(state) {
+    state.turnActive = true;
+    state.turnId = generateTurnId();
+    state.stateVersion++;
+    state.startedToolIds.clear();
+    state.pendingToolInputs.clear();
+    state.lastUsage = null;
+    sendFn({
+        type: 'turn_started',
+        conversationId: state.conversationId,
+        claudeSessionId: state.yeaftSessionId,
+        turnId: state.turnId,
+        stateVersion: state.stateVersion,
+    });
+    if (!state.heartbeatTimer) {
+        state.heartbeatTimer = setInterval(() => {
+            if (!state.turnActive) {
+                if (state.heartbeatTimer)
+                    clearInterval(state.heartbeatTimer);
+                state.heartbeatTimer = null;
+                return;
+            }
+            sendFn({
+                type: 'turn_heartbeat',
+                conversationId: state.conversationId,
+                claudeSessionId: state.yeaftSessionId,
+                turnId: state.turnId,
+                stateVersion: state.stateVersion,
+                phase: 'running',
+                lastActivityAt: Date.now(),
+            });
+        }, TURN_HEARTBEAT_INTERVAL_MS);
+    }
+}
+function finishYeaftTurn(state) {
+    state.turnActive = false;
+    state.stateVersion++;
+    state.startedToolIds.clear();
+    state.pendingToolInputs.clear();
+    if (state.heartbeatTimer) {
+        clearInterval(state.heartbeatTimer);
+        state.heartbeatTimer = null;
+    }
+}
+function emitYeaftCancelled(conversationId, state) {
+    sendFn({
+        type: 'backend_event',
+        conversationId,
+        event: { type: 'turn_cancelled', session: sessionRef(state?.yeaftSessionId || '') },
+    });
+    sendFn({
+        type: 'execution_cancelled',
+        conversationId,
+        claudeSessionId: state?.yeaftSessionId || null,
+        turnId: state?.turnId || null,
+        stateVersion: state?.stateVersion || 0,
+    });
+}
+function buildYeaftUsage(state, rawUsage) {
+    return {
+        provider: 'yeaft',
+        model: state.model || textFromUnknown(rawUsage?.model) || undefined,
+        reasoningEffort: state.effort || undefined,
+        inputTokens: numberOrUndefined(rawUsage?.input_tokens),
+        outputTokens: numberOrUndefined(rawUsage?.output_tokens),
+        cacheReadInputTokens: numberOrUndefined(rawUsage?.cache_read_input_tokens),
+        cacheCreationInputTokens: numberOrUndefined(rawUsage?.cache_creation_input_tokens),
+    };
+}
+function numberOrUndefined(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function textFromUnknown(value) {
+    return typeof value === 'string' ? value : '';
+}
+function stringArrayFromUnknown(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === 'string' && item.length > 0);
+}
+function scopeFromYeaftEvent(event) {
+    const vpId = textFromUnknown(event.vpId) || textFromUnknown(event.vp_id);
+    const threadId = textFromUnknown(event.threadId) || textFromUnknown(event.thread_id);
+    return {
+        ...(vpId ? { vpId } : {}),
+        ...(threadId ? { threadId } : {}),
+    };
+}
+function sendYeaftSetupError(state, message) {
+    sendFn({ type: 'backend_event', conversationId: state.conversationId, event: { type: 'error', message } });
+    sendFn({ type: 'backend_event', conversationId: state.conversationId, event: { type: 'turn_completed', session: sessionRef(state.yeaftSessionId || '') } });
+    sendFn({
+        type: 'turn_completed',
+        conversationId: state.conversationId,
+        workDir: state.workDir,
+        claudeSessionId: state.yeaftSessionId,
+        turnId: state.turnId,
+        stateVersion: state.stateVersion,
+    });
+}
+let resolvedYeaftPath = null;
+function resolveCmdWrapperDirectExecution(cmdPath) {
+    if (platform() !== 'win32')
+        return null;
+    if (!cmdPath.toLowerCase().endsWith('.cmd'))
+        return null;
+    try {
+        const content = readFileSync(cmdPath, 'utf-8');
+        const jsMatch = content.match(/%dp0%\\(.+?\.js)"/i) ||
+            content.match(/%dp0%\\(.+?\.js)/i);
+        if (jsMatch) {
+            const scriptPath = join(dirname(cmdPath), jsMatch[1].replace(/\\/g, '/'));
+            if (existsSync(scriptPath)) {
+                return { command: process.execPath, prefixArgs: [scriptPath] };
+            }
+        }
+        const exeMatch = content.match(/%dp0%\\(.+?\.exe)"/i) ||
+            content.match(/%dp0%\\(.+?\.exe)/i);
+        if (exeMatch) {
+            const exePath = join(dirname(cmdPath), exeMatch[1].replace(/\\/g, '/'));
+            if (existsSync(exePath)) {
+                return { command: exePath, prefixArgs: [] };
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+function resolveYeaftPath() {
+    if (resolvedYeaftPath)
+        return resolvedYeaftPath;
+    resolvedYeaftPath = resolveExecutablePath('yeaft') || 'yeaft';
+    console.log(`[Yeaft] Resolved command: ${resolvedYeaftPath}`);
+    return resolvedYeaftPath;
+}
+export function _resetResolvedYeaftPathForTests() {
+    resolvedYeaftPath = null;
+    resetCachedExecutablePath('yeaft');
+}
+export function getYeaftConversation(conversationId) {
+    return conversations.get(conversationId);
+}
+export function getYeaftConversations() {
+    return conversations;
+}
+export function rebindYeaftConversation(yeaftSessionId, newConvId) {
+    for (const [oldConvId, state] of conversations) {
+        if ((state.yeaftSessionId === yeaftSessionId || state.lastYeaftSessionId === yeaftSessionId) && oldConvId !== newConvId) {
+            conversations.delete(oldConvId);
+            state.conversationId = newConvId;
+            conversations.set(newConvId, state);
+            return true;
+        }
+    }
+    return false;
+}
+export function createYeaftPlaceholder(conversationId, opts) {
+    if (conversations.has(conversationId))
+        return;
+    conversations.set(conversationId, {
+        conversationId,
+        child: null,
+        abortController: null,
+        yeaftSessionId: null,
+        lastYeaftSessionId: null,
+        workDir: process.cwd(),
+        turnActive: false,
+        providerId: opts?.providerId || 'yeaft',
+        model: null,
+        effort: null,
+        vps: [],
+        defaultVpId: null,
+        turnId: null,
+        stateVersion: 0,
+        heartbeatTimer: null,
+        sessionNotified: false,
+        startedToolIds: new Set(),
+        pendingToolInputs: new Map(),
+        lastUsage: null,
+        stderrBuf: '',
+    });
+}
+export function restartYeaftConversation(conversationId, opts) {
+    const state = conversations.get(conversationId);
+    const wasTurnActive = state?.turnActive || false;
+    const yeaftSessionId = state?.yeaftSessionId || null;
+    if (state)
+        cleanupYeaftConversation(conversationId);
+    createYeaftPlaceholder(conversationId, { providerId: opts?.providerId || state?.providerId || 'yeaft' });
+    const next = conversations.get(conversationId);
+    next.lastYeaftSessionId = yeaftSessionId;
+    next.workDir = state?.workDir || process.cwd();
+    next.model = opts?.model || state?.model || null;
+    next.effort = opts?.effort || state?.effort || null;
+    next.vps = opts?.vps || state?.vps || [];
+    next.defaultVpId = next.vps.includes(state?.defaultVpId || '')
+        ? state.defaultVpId
+        : next.vps[0] || null;
+    next.stateVersion = (state?.stateVersion || 0) + 1;
+    return { wasTurnActive, yeaftSessionId };
+}
+function normalizeYeaftRunOptions(input) {
+    const options = {};
+    if (!input)
+        return { options };
+    if (input.model != null && input.model !== '') {
+        const model = input.model.trim();
+        if (model.length > 120 || !MODEL_PATTERN.test(model))
+            return { options, error: `Invalid Yeaft model name: ${input.model}` };
+        options.model = model;
+    }
+    if (input.effort != null && input.effort !== '' && input.effort !== 'default') {
+        const effort = input.effort.trim();
+        if (effort.length > 64 || !EFFORT_PATTERN.test(effort))
+            return { options, error: `Invalid Yeaft effort value: ${input.effort}` };
+        options.effort = effort;
+    }
+    const rawVps = Array.isArray(input.vps) ? input.vps : [];
+    const legacyVp = typeof input.vp?.id === 'string' ? input.vp.id : '';
+    const ids = [...rawVps, ...(legacyVp ? [legacyVp] : [])];
+    const vps = [];
+    const seen = new Set();
+    for (const raw of ids) {
+        const id = typeof raw === 'string' ? raw.trim() : '';
+        if (!id)
+            continue;
+        if (id.length > 64 || !VP_ID_PATTERN.test(id))
+            return { options, error: 'Invalid Yeaft VP id' };
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        vps.push(id);
+    }
+    if (vps.length)
+        options.vps = vps;
+    return { options };
+}
+export function handleYeaftChat(conversationId, text, workDir, options, files) {
+    let state = conversations.get(conversationId);
+    if (!state) {
+        createYeaftPlaceholder(conversationId, { providerId: options?.providerId || 'yeaft' });
+        state = conversations.get(conversationId);
+    }
+    state.workDir = workDir;
+    if (options?.providerId)
+        state.providerId = options.providerId;
+    const resumeId = options?.resumeSessionId || state.yeaftSessionId || state.lastYeaftSessionId || generateYeaftSessionId(conversationId);
+    if (!validYeaftSessionId(resumeId)) {
+        sendYeaftSetupError(state, `Invalid Yeaft session id: ${resumeId}`);
+        return;
+    }
+    state.yeaftSessionId = resumeId;
+    state.lastYeaftSessionId = resumeId;
+    const normalized = normalizeYeaftRunOptions(options?.yeaftOptions);
+    if (normalized.error) {
+        sendYeaftSetupError(state, normalized.error);
+        return;
+    }
+    if (normalized.options.model)
+        state.model = normalized.options.model;
+    if (normalized.options.effort)
+        state.effort = normalized.options.effort;
+    if (normalized.options.vps) {
+        state.vps = normalized.options.vps;
+        if (!state.defaultVpId || !state.vps.includes(state.defaultVpId)) {
+            state.defaultVpId = null;
+        }
+    }
+    persistYeaftSessionMetadata(state);
+    if (files?.length) {
+        sendYeaftSetupError(state, 'Yeaft attachments are not supported yet.');
+        return;
+    }
+    if (!state.child) {
+        startYeaftProcess(state);
+    }
+    if (!state.child?.stdin || state.child.stdin.destroyed) {
+        sendYeaftSetupError(state, 'Yeaft process is not accepting input.');
+        return;
+    }
+    startYeaftTurn(state);
+    sendFn({
+        type: 'backend_event',
+        conversationId,
+        event: { type: 'turn_started', session: sessionRef(state.yeaftSessionId), turnId: state.turnId || undefined },
+    });
+    const userPayload = {
+        type: 'user',
+        prompt: text,
+        ...(state.vps.length ? {
+            vps: state.vps,
+            vp: { id: state.defaultVpId || state.vps[0] },
+            vpId: state.defaultVpId || state.vps[0],
+            roster: state.vps,
+            defaultVpId: state.defaultVpId || state.vps[0],
+        } : {}),
+    };
+    state.child.stdin.write(JSON.stringify(userPayload) + '\n');
+}
+function persistYeaftSessionMetadata(state) {
+    if (!state.yeaftSessionId || !state.workDir)
+        return;
+    const sessionDir = join(homedir(), '.yeaft', 'sessions', state.yeaftSessionId);
+    const sessionFile = join(sessionDir, 'session.json');
+    const legacySessionFile = join(sessionDir, 'group.json');
+    try {
+        mkdirSync(sessionDir, { recursive: true });
+        const canonical = readJsonObject(sessionFile) || {};
+        const legacy = readJsonObject(legacySessionFile) || {};
+        const canonicalIsFormal = typeof canonical.id === 'string' && Array.isArray(canonical.roster);
+        const recoveredRoster = canonicalIsFormal
+            ? canonical.roster
+            : [...new Set([
+                    ...stringArrayFromUnknown(legacy.roster),
+                    ...stringArrayFromUnknown(canonical.roster),
+                ])];
+        const existing = {
+            ...legacy,
+            ...canonical,
+            roster: recoveredRoster,
+            ...(!canonicalIsFormal
+                && typeof canonical.defaultVpId !== 'string'
+                && typeof legacy.defaultVpId === 'string'
+                ? { defaultVpId: legacy.defaultVpId }
+                : {}),
+        };
+        const now = new Date().toISOString();
+        const existingRoster = stringArrayFromUnknown(existing.roster);
+        const roster = state.vps.length ? state.vps : existingRoster;
+        if (!state.vps.length && roster.length)
+            state.vps = roster;
+        const existingDefaultVpId = textFromUnknown(existing.defaultVpId);
+        const defaultVpId = state.defaultVpId && roster.includes(state.defaultVpId)
+            ? state.defaultVpId
+            : canonicalIsFormal
+                && Object.prototype.hasOwnProperty.call(canonical, 'defaultVpId')
+                && canonical.defaultVpId === null
+                ? null
+                : roster.includes(existingDefaultVpId)
+                    ? existingDefaultVpId
+                    : roster[0] || null;
+        state.defaultVpId = defaultVpId;
+        let workspaceKey = '';
+        try {
+            workspaceKey = realpathSync(resolve(state.workDir));
+        }
+        catch { /* keep empty */ }
+        const next = {
+            ...existing,
+            id: state.yeaftSessionId,
+            name: textFromUnknown(existing.name) || state.yeaftSessionId,
+            workDir: state.workDir,
+            workspaceKey,
+            announcement: textFromUnknown(existing.announcement),
+            providerId: state.providerId,
+            sessionId: state.yeaftSessionId,
+            roster,
+            defaultVpId,
+            createdAt: textFromUnknown(existing.createdAt) || now,
+            metadataUpdatedAt: now,
+        };
+        writeFileSync(sessionFile, JSON.stringify(next, null, 2) + '\n', 'utf-8');
+    }
+    catch {
+        // Best-effort only. Yeaft can still run; this metadata powers AgentLink's
+        // directory-scoped session lists when Yeaft stores history under ~/.yeaft.
+    }
+}
+function startYeaftProcess(state) {
+    const args = [
+        '--input-format', 'stream-json',
+        '--output-format', 'stream-json',
+        '--session-id', state.yeaftSessionId,
+        '--cwd', state.workDir,
+    ];
+    if (state.model)
+        args.push('--model', state.model);
+    if (state.effort)
+        args.push('--effort', state.effort);
+    const provider = getProvider(state.providerId);
+    const { command, prefixArgs, spawnOpts } = state.providerId === 'yeaft'
+        ? { command: resolveYeaftPath(), prefixArgs: [], spawnOpts: {} }
+        : resolveProviderCommand(provider);
+    const direct = resolveCmdWrapperDirectExecution(command);
+    let spawnCmd;
+    let spawnArgs;
+    if (direct) {
+        spawnCmd = direct.command;
+        spawnArgs = [...direct.prefixArgs, ...prefixArgs, ...args];
+    }
+    else if (platform() === 'win32' && command.toLowerCase().endsWith('.cmd')) {
+        spawnCmd = process.env.COMSPEC || 'cmd.exe';
+        spawnArgs = ['/c', command, ...prefixArgs, ...args];
+    }
+    else {
+        spawnCmd = command;
+        spawnArgs = [...prefixArgs, ...args];
+    }
+    const controller = new AbortController();
+    state.abortController = controller;
+    state.stderrBuf = '';
+    const child = spawn(spawnCmd, spawnArgs, {
+        cwd: provider.cwd || state.workDir,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: { ...getCleanEnv(), ...(provider.env || {}) },
+        signal: controller.signal,
+        ...spawnOpts,
+        windowsHide: true,
+    });
+    state.child = child;
+    const rl = createInterface({ input: child.stdout });
+    child.stderr?.on('data', (chunk) => { state.stderrBuf += chunk.toString(); });
+    rl.on('line', (line) => {
+        if (!line.trim())
+            return;
+        try {
+            const event = JSON.parse(line);
+            handleYeaftEvent(state, event);
+        }
+        catch {
+            state.stderrBuf += `${line}\n`;
+        }
+    });
+    child.on('close', (code) => {
+        if (state.child !== child)
+            return;
+        state.child = null;
+        state.abortController = null;
+        if (state.turnActive) {
+            finishYeaftTurn(state);
+            const errMsg = state.stderrBuf.trim()
+                || (code !== 0 && code !== null
+                    ? `Yeaft process exited with code ${code}`
+                    : 'Yeaft process exited before emitting an aggregate turn result');
+            sendFn({ type: 'backend_event', conversationId: state.conversationId, event: { type: 'error', message: errMsg } });
+            emitYeaftTurnCompleted(state);
+        }
+    });
+    child.on('error', (err) => {
+        if (state.child !== child)
+            return;
+        state.child = null;
+        state.abortController = null;
+        finishYeaftTurn(state);
+        sendFn({ type: 'backend_event', conversationId: state.conversationId, event: { type: 'error', message: `Failed to start yeaft: ${err.message}` } });
+        emitYeaftTurnCompleted(state);
+    });
+}
+function handleYeaftEvent(state, event) {
+    const convId = state.conversationId;
+    const type = String(event.type || '');
+    const subtype = String(event.subtype || '');
+    const sessionId = textFromUnknown(event.session_id) || state.yeaftSessionId || '';
+    if (sessionId) {
+        state.yeaftSessionId = sessionId;
+        state.lastYeaftSessionId = sessionId;
+    }
+    const ref = sessionRef(state.yeaftSessionId || sessionId || 'pending');
+    const scope = scopeFromYeaftEvent(event);
+    if (type === 'system' && subtype === 'init') {
+        if (!state.sessionNotified) {
+            state.sessionNotified = true;
+            sendFn({ type: 'backend_event', conversationId: convId, event: { type: 'session_started', session: ref } });
+        }
+        return;
+    }
+    if (type === 'turn' && subtype === 'start') {
+        const turnId = textFromUnknown(event.turn_id);
+        if (turnId)
+            state.turnId = turnId;
+        sendFn({ type: 'backend_event', conversationId: convId, event: { type: 'turn_started', session: ref, turnId: state.turnId || undefined, ...scope } });
+        return;
+    }
+    if (type === 'assistant' && subtype === 'text_delta') {
+        const delta = event.delta;
+        const text = textFromUnknown(delta?.text) || textFromUnknown(event.text);
+        if (text)
+            sendFn({ type: 'backend_event', conversationId: convId, event: { type: 'text_delta', session: ref, text, ...scope } });
+        return;
+    }
+    if (type === 'assistant' && subtype === 'thinking_delta') {
+        const delta = event.delta;
+        const text = textFromUnknown(delta?.thinking) || textFromUnknown(delta?.text) || textFromUnknown(event.text);
+        if (text)
+            sendFn({ type: 'backend_event', conversationId: convId, event: { type: 'reasoning_delta', session: ref, text, ...scope } });
+        return;
+    }
+    if (type === 'assistant' && subtype === 'tool_use') {
+        const content = Array.isArray(event.content) ? event.content : [];
+        for (const item of content) {
+            if (!item || typeof item !== 'object')
+                continue;
+            const tool = item;
+            const id = textFromUnknown(tool.id) || generateToolId('yeaft-tool');
+            const name = textFromUnknown(tool.name) || 'tool';
+            state.pendingToolInputs.set(id, tool.input);
+            emitToolStarted(state, id, name, tool.input, scope);
+        }
+        return;
+    }
+    if (type === 'tool' && subtype === 'start') {
+        const id = textFromUnknown(event.tool_use_id) || generateToolId('yeaft-tool');
+        const name = textFromUnknown(event.name) || 'tool';
+        state.pendingToolInputs.set(id, event.input);
+        emitToolStarted(state, id, name, event.input, scope);
+        return;
+    }
+    if (type === 'tool' && subtype === 'result') {
+        const id = textFromUnknown(event.tool_use_id) || generateToolId('yeaft-tool');
+        const name = textFromUnknown(event.name) || 'tool';
+        emitToolCompleted(state, id, name, event.content, !!event.is_error, scope);
+        return;
+    }
+    if (type === 'task') {
+        sendFn({
+            type: 'backend_event',
+            conversationId: convId,
+            event: {
+                type: 'task_updated',
+                session: ref,
+                update: { subtype: subtype || 'updated', task: event.task || null },
+                ...scope,
+            },
+        });
+        return;
+    }
+    if (type === 'sub_agent') {
+        sendFn({
+            type: 'backend_event',
+            conversationId: convId,
+            event: {
+                type: 'sub_agent_updated',
+                session: ref,
+                update: {
+                    subtype: subtype || 'event',
+                    agentId: textFromUnknown(event.agent_id) || textFromUnknown(event.payload?.agentId),
+                    payload: event.payload || {},
+                },
+                ...scope,
+            },
+        });
+        return;
+    }
+    if (type === 'async_task') {
+        sendFn({
+            type: 'backend_event',
+            conversationId: convId,
+            event: {
+                type: 'async_task_wait',
+                session: ref,
+                wait: {
+                    status: subtype === 'wait_start' ? 'waiting' : 'resumed',
+                    pendingTaskIds: stringArrayFromUnknown(event.pending_task_ids),
+                    remainingTaskIds: stringArrayFromUnknown(event.remaining_task_ids),
+                    aborted: !!event.aborted,
+                },
+                ...scope,
+            },
+        });
+        return;
+    }
+    if (type === 'usage') {
+        const usage = buildYeaftUsage(state, event.usage);
+        state.lastUsage = usage;
+        sendFn({ type: 'backend_event', conversationId: convId, event: { type: 'usage_update', session: ref, usage, ...scope } });
+        return;
+    }
+    if (type === 'ask_user' && subtype === 'request') {
+        const requestId = textFromUnknown(event.request_id) || generateToolId('ask');
+        const question = textFromUnknown(event.question) || 'Input requested';
+        const options = Array.isArray(event.options)
+            ? event.options.map((value) => ({ label: String(value) }))
+            : [];
+        sendFn({
+            type: 'backend_event',
+            conversationId: convId,
+            event: {
+                type: 'user_input_requested',
+                session: ref,
+                requestId,
+                request: { source: 'ask_user_question', questions: [{ question, options }] },
+                ...scope,
+            },
+        });
+        return;
+    }
+    if (type === 'error') {
+        const raw = event.error;
+        const message = textFromUnknown(raw?.message) || textFromUnknown(event.message) || 'Yeaft turn failed';
+        sendFn({ type: 'backend_event', conversationId: convId, event: { type: 'error', session: ref, message, ...scope } });
+        return;
+    }
+    if (type === 'result') {
+        const usage = buildYeaftUsage(state, event.usage);
+        state.lastUsage = usage;
+        if (event.is_error || subtype === 'error') {
+            sendFn({ type: 'backend_event', conversationId: convId, event: { type: 'error', session: ref, message: textFromUnknown(event.error) || 'Yeaft turn failed', ...scope } });
+        }
+        // Per-VP/ad-hoc results may be scoped or unscoped. Only the stream-json
+        // aggregate carries both marker arrays and terminates the global turn.
+        const isAggregateResult = Array.isArray(event.vp_results)
+            && Array.isArray(event.dispatched_vp_ids);
+        if (scope.vpId || scope.threadId || !isAggregateResult)
+            return;
+        finishYeaftTurn(state);
+        emitYeaftTurnCompleted(state, usage);
+    }
+}
+function generateToolId(prefix) {
+    return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function emitToolStarted(state, id, name, input, scope = {}) {
+    if (state.startedToolIds.has(id))
+        return;
+    state.startedToolIds.add(id);
+    const displayName = name === 'route_forward' ? 'RouteForward' : name;
+    sendFn({
+        type: 'backend_event',
+        conversationId: state.conversationId,
+        event: {
+            type: 'tool_started',
+            session: sessionRef(state.yeaftSessionId || 'pending'),
+            tool: { id, name: displayName, itemKind: displayName, input, status: 'in_progress' },
+            ...scope,
+        },
+    });
+}
+function emitToolCompleted(state, id, name, output, isError, scope = {}) {
+    if (!state.startedToolIds.has(id))
+        emitToolStarted(state, id, name, state.pendingToolInputs.get(id), scope);
+    const displayName = name === 'route_forward' ? 'RouteForward' : name;
+    sendFn({
+        type: 'backend_event',
+        conversationId: state.conversationId,
+        event: {
+            type: 'tool_completed',
+            session: sessionRef(state.yeaftSessionId || 'pending'),
+            tool: { id, name: displayName, output, isError, status: isError ? 'error' : 'completed' },
+            ...scope,
+        },
+    });
+}
+function emitYeaftTurnCompleted(state, usage = state.lastUsage) {
+    sendFn({
+        type: 'backend_event',
+        conversationId: state.conversationId,
+        event: { type: 'turn_completed', session: sessionRef(state.yeaftSessionId || ''), ...(usage ? { usage } : {}) },
+    });
+    sendFn({
+        type: 'turn_completed',
+        conversationId: state.conversationId,
+        workDir: state.workDir,
+        claudeSessionId: state.yeaftSessionId,
+        turnId: state.turnId,
+        stateVersion: state.stateVersion,
+        ...(usage ? { usage } : {}),
+    });
+}
+export function handleYeaftUserAnswer(requestId, answers, opts = {}) {
+    const payload = JSON.stringify({ type: 'ask_user_response', request_id: requestId, answers }) + '\n';
+    const candidates = [
+        ...(opts.conversationId ? [conversations.get(opts.conversationId)] : []),
+        ...conversations.values(),
+    ];
+    const seen = new Set();
+    for (const state of candidates) {
+        if (!state || seen.has(state))
+            continue;
+        seen.add(state);
+        if (state.child?.stdin && !state.child.stdin.destroyed) {
+            state.child.stdin.write(payload);
+            return;
+        }
+    }
+}
+export function cancelYeaftExecution(conversationId) {
+    const state = conversations.get(conversationId);
+    if (!state) {
+        emitYeaftCancelled(conversationId);
+        return;
+    }
+    if (!state.child) {
+        if (state.turnActive)
+            finishYeaftTurn(state);
+        emitYeaftCancelled(conversationId, state);
+        return;
+    }
+    finishYeaftTurn(state);
+    emitYeaftCancelled(conversationId, state);
+    if (platform() === 'win32') {
+        try {
+            spawn('cmd', ['/c', 'taskkill', '/pid', String(state.child.pid), '/f', '/t'], { stdio: 'ignore', windowsHide: true });
+        }
+        catch { /* ignore */ }
+    }
+    else {
+        state.child.kill('SIGTERM');
+    }
+    state.child = null;
+    state.abortController = null;
+}
+function cleanupYeaftConversation(conversationId) {
+    const state = conversations.get(conversationId);
+    if (!state)
+        return;
+    if (state.child) {
+        try {
+            state.child.stdin?.end();
+        }
+        catch { /* ignore */ }
+        cancelYeaftExecution(conversationId);
+    }
+    if (state.heartbeatTimer)
+        clearInterval(state.heartbeatTimer);
+    if (state.yeaftSessionId)
+        state.lastYeaftSessionId = state.yeaftSessionId;
+    conversations.delete(conversationId);
+}
+export function cleanupAllYeaftConversations() {
+    for (const convId of conversations.keys())
+        cleanupYeaftConversation(convId);
+}
+export function evictByYeaftSessionId(yeaftSessionId) {
+    for (const [convId, conv] of conversations) {
+        if (conv.yeaftSessionId === yeaftSessionId || conv.lastYeaftSessionId === yeaftSessionId) {
+            if (conv.turnActive)
+                return true;
+            cleanupYeaftConversation(convId);
+        }
+    }
+    return false;
+}
+function normalizeCursorPath(value) {
+    const normalized = value.replace(/\\/g, '/').replace(/\/+$/, '');
+    return process.platform === 'win32' ? normalized.toLowerCase() : normalized;
+}
+function normalizeSessionLimit(limit) {
+    if (limit == null)
+        return YEAFT_SESSION_LIST_LIMIT;
+    if (limit === Number.POSITIVE_INFINITY)
+        return Number.POSITIVE_INFINITY;
+    if (!Number.isFinite(limit) || limit <= 0)
+        return YEAFT_SESSION_LIST_LIMIT;
+    return Math.min(Math.floor(limit), 500);
+}
+function compareCursorSortKeys(a, b) {
+    const lastModifiedDiff = b.lastModified - a.lastModified;
+    if (lastModifiedDiff !== 0)
+        return lastModifiedDiff;
+    const sessionDiff = a.sessionId.localeCompare(b.sessionId);
+    if (sessionDiff !== 0)
+        return sessionDiff;
+    return a.tieBreaker.localeCompare(b.tieBreaker);
+}
+function encodeYeaftCursor(scope, sortKey, workDir) {
+    return Buffer.from(JSON.stringify({
+        v: 1,
+        provider: 'yeaft',
+        scope,
+        ...(scope === 'workdir' && workDir ? { workDir: normalizeCursorPath(workDir) } : {}),
+        lastModified: sortKey.lastModified,
+        sessionId: sortKey.sessionId,
+        tieBreaker: sortKey.tieBreaker,
+    }), 'utf-8').toString('base64url');
+}
+function decodeYeaftCursor(cursor, scope, workDir) {
+    let parsed;
+    try {
+        parsed = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf-8'));
+    }
+    catch {
+        throw new Error('Invalid yeaft session list cursor');
+    }
+    if (!parsed || typeof parsed !== 'object')
+        throw new Error('Invalid yeaft session list cursor');
+    const value = parsed;
+    if (value.v !== 1 || value.provider !== 'yeaft' || value.scope !== scope || typeof value.lastModified !== 'number' || !Number.isFinite(value.lastModified) || typeof value.sessionId !== 'string' || typeof value.tieBreaker !== 'string') {
+        throw new Error('Invalid yeaft session list cursor');
+    }
+    if (scope === 'workdir' && value.workDir !== normalizeCursorPath(workDir || ''))
+        throw new Error('Yeaft session list cursor does not match requested workDir');
+    return { lastModified: value.lastModified, sessionId: value.sessionId, tieBreaker: value.tieBreaker };
+}
+function yeaftRoots(workDir) {
+    const roots = [join(homedir(), '.yeaft')];
+    if (workDir)
+        roots.push(join(workDir, '.yeaft'));
+    return Array.from(new Set(roots.map(root => resolve(root))));
+}
+function listYeaftSessionDirs(workDir) {
+    const result = [];
+    for (const root of yeaftRoots(workDir)) {
+        const sessionsDir = join(root, 'sessions');
+        if (!existsSync(sessionsDir))
+            continue;
+        let entries;
+        try {
+            entries = readdirSync(sessionsDir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name.startsWith('.'))
+                continue;
+            result.push(join(sessionsDir, entry.name));
+        }
+    }
+    return result;
+}
+function loadTitleMap() {
+    try {
+        const parsed = JSON.parse(readFileSync(YEAFT_TITLES_FILE, 'utf-8'));
+        return parsed && typeof parsed === 'object' ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function writeTitleMap(map) {
+    if (!existsSync(CONFIG_DIR))
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(YEAFT_TITLES_FILE, JSON.stringify(map, null, 2) + '\n', 'utf-8');
+}
+function setCustomTitle(sessionId, title) {
+    const map = loadTitleMap();
+    map[sessionId] = title;
+    writeTitleMap(map);
+}
+function removeCustomTitle(sessionId) {
+    const map = loadTitleMap();
+    if (Object.prototype.hasOwnProperty.call(map, sessionId)) {
+        delete map[sessionId];
+        writeTitleMap(map);
+    }
+}
+function isRawYeaftSessionTitle(title, sessionId) {
+    const trimmed = title.trim();
+    return !trimmed || trimmed === sessionId || SESSION_ID_PATTERN.test(trimmed);
+}
+function parseSessionDir(sessionDir, stats) {
+    const sessionId = sessionDir.replace(/\\/g, '/').split('/').pop() || '';
+    if (!sessionId)
+        return null;
+    const meta = readJsonObject(join(sessionDir, 'session.json')) || readJsonObject(join(sessionDir, 'group.json')) || {};
+    let firstPrompt = '';
+    let lastAssistant = '';
+    let projectPath = textFromUnknown(meta.workDir);
+    let lastModified = Date.parse(textFromUnknown(meta.createdAt)) || stats.mtimeMs;
+    for (const row of readSessionRows(sessionDir)) {
+        const ts = Date.parse(textFromUnknown(row.time) || textFromUnknown(row.ts) || textFromUnknown(row.timestamp));
+        if (Number.isFinite(ts) && ts > lastModified)
+            lastModified = ts;
+        if (!projectPath)
+            projectPath = textFromUnknown(row.cwd) || textFromUnknown(row.workDir);
+        const role = textFromUnknown(row.role) || (row.from === 'user' ? 'user' : '');
+        const content = rowText(row);
+        if (role === 'user' && content && !firstPrompt)
+            firstPrompt = content.substring(0, 100);
+        if (role === 'assistant' && content)
+            lastAssistant = content.substring(0, 120);
+    }
+    const titleMap = loadTitleMap();
+    const customTitle = titleMap[sessionId];
+    const metaTitle = textFromUnknown(meta.name);
+    const usableMetaTitle = isRawYeaftSessionTitle(metaTitle, sessionId) ? '' : metaTitle;
+    const title = customTitle || usableMetaTitle || firstPrompt || lastAssistant || sessionId.slice(0, 24);
+    return {
+        sessionId,
+        title,
+        ...(customTitle ? { customTitle } : {}),
+        preview: lastAssistant || firstPrompt || title,
+        firstPrompt: firstPrompt || title,
+        lastModified,
+        projectPath,
+        projectFolder: projectPath.replace(/[\\/]+$/, '').split(/[\\/]/).pop() || projectPath,
+        sourcePath: sessionDir,
+    };
+}
+function readJsonObject(filePath) {
+    try {
+        const parsed = JSON.parse(readFileSync(filePath, 'utf-8'));
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function collectFiles(root, out = []) {
+    let entries;
+    try {
+        entries = readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const entry of entries) {
+        const full = join(root, entry.name);
+        if (entry.isDirectory())
+            collectFiles(full, out);
+        else if (entry.isFile() && /\.(jsonl|json|md)$/i.test(entry.name))
+            out.push(full);
+    }
+    return out;
+}
+function collectYeaftHistoryFiles(sessionDir) {
+    const normalizedSessionDir = normalizeCursorPath(sessionDir);
+    const files = collectFiles(sessionDir);
+    const conversationFiles = files.filter((file) => {
+        const normalized = normalizeCursorPath(file);
+        return normalized.startsWith(`${normalizedSessionDir}/conversation/segments/`) && /\.jsonl$/i.test(file);
+    });
+    if (conversationFiles.length)
+        return conversationFiles.sort();
+    // Legacy Yeaft sessions used flatter event/message logs. Only fall back to
+    // those when the canonical conversation store is absent; otherwise the same
+    // shared user turn can appear both in messages/ and conversation/segments/.
+    return files.filter((file) => {
+        const normalized = normalizeCursorPath(file);
+        if (normalized.includes(`${normalizedSessionDir}/debug/`))
+            return false;
+        if (normalized.endsWith('/session.json') || normalized.endsWith('/group.json') || normalized.endsWith('/index.json'))
+            return false;
+        return /\.(jsonl|json)$/i.test(file);
+    }).sort();
+}
+function readSessionRows(sessionDir) {
+    const rows = [];
+    for (const file of collectYeaftHistoryFiles(sessionDir)) {
+        const normalized = file.replace(/\\/g, '/');
+        if (normalized.endsWith('/session.json') || normalized.endsWith('/group.json') || normalized.endsWith('/index.json'))
+            continue;
+        let content = '';
+        try {
+            content = readFileSync(file, 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        for (const line of content.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed.startsWith('{'))
+                continue;
+            try {
+                const parsed = JSON.parse(trimmed);
+                if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+                    rows.push(parsed);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    rows.sort((a, b) => {
+        const at = Date.parse(textFromUnknown(a.time) || textFromUnknown(a.ts) || textFromUnknown(a.timestamp));
+        const bt = Date.parse(textFromUnknown(b.time) || textFromUnknown(b.ts) || textFromUnknown(b.timestamp));
+        if (Number.isFinite(at) && Number.isFinite(bt) && at !== bt)
+            return at - bt;
+        return textFromUnknown(a.id).localeCompare(textFromUnknown(b.id));
+    });
+    return rows;
+}
+function rowText(row) {
+    const content = row.content ?? row.text ?? row.message;
+    if (typeof content === 'string')
+        return content.trim();
+    if (Array.isArray(content))
+        return content.map((item) => {
+            if (!item || typeof item !== 'object')
+                return '';
+            const r = item;
+            return textFromUnknown(r.text) || textFromUnknown(r.content);
+        }).filter(Boolean).join('').trim();
+    if (content && typeof content === 'object') {
+        const r = content;
+        return textFromUnknown(r.text) || textFromUnknown(r.content);
+    }
+    return '';
+}
+function rowVpId(row) {
+    const meta = row.meta && typeof row.meta === 'object' ? row.meta : null;
+    return textFromUnknown(row.vpId)
+        || textFromUnknown(row.vp_id)
+        || textFromUnknown(row.speakerVpId)
+        || textFromUnknown(row.speaker_vp_id)
+        || textFromUnknown(row.senderVpId)
+        || textFromUnknown(meta?.senderVpId);
+}
+function rowThreadId(row) {
+    const meta = row.meta && typeof row.meta === 'object' ? row.meta : null;
+    return textFromUnknown(row.threadId)
+        || textFromUnknown(row.thread_id)
+        || textFromUnknown(meta?.sourceThreadId);
+}
+function rowTimestamp(row) {
+    return textFromUnknown(row.time) || textFromUnknown(row.ts) || textFromUnknown(row.timestamp) || undefined;
+}
+function shouldShowYeaftConversationRow(row, role, content) {
+    if (row.internal === true || row.hidden === true)
+        return false;
+    if (role === 'user' && row.userAuthored === false)
+        return false;
+    if (role === 'assistant')
+        return !!content || (Array.isArray(row.toolCalls) && row.toolCalls.length > 0);
+    if (role === 'user')
+        return !!content;
+    if (role === 'tool')
+        return !!(content || row.output || row.toolOutput || row.toolCallId || row.tool_call_id || row.tool_use_id);
+    return false;
+}
+function historyMessageKey(msg) {
+    return [
+        msg.role,
+        msg.content || '',
+        msg.toolName || '',
+        msg.toolId || '',
+        msg.toolInput || '',
+        msg.toolOutput || '',
+        msg.providerId || '',
+        msg.vpId || '',
+        msg.threadId || '',
+        msg.timestamp || '',
+    ].join('\n');
+}
+function userPromptKey(content, row) {
+    const clientMessageId = textFromUnknown(row.clientMessageId) || textFromUnknown(row.client_message_id);
+    if (clientMessageId)
+        return `id:${clientMessageId}`;
+    return `content:${content}`;
+}
+function pushUniqueHistoryMessage(messages, seen, msg) {
+    const key = historyMessageKey(msg);
+    if (seen.has(key))
+        return;
+    seen.add(key);
+    messages.push(msg);
+}
+function getYeaftSessionEntries(workDir) {
+    const normalizedWorkDir = workDir ? normalizeCursorPath(workDir) : '';
+    const normalizedWorkDirSessionRoot = workDir ? normalizeCursorPath(join(workDir, '.yeaft', 'sessions')) : '';
+    const entries = [];
+    for (const sessionDir of listYeaftSessionDirs(workDir)) {
+        let stats;
+        try {
+            stats = statSync(sessionDir);
+        }
+        catch {
+            continue;
+        }
+        const parsed = parseSessionDir(sessionDir, stats);
+        if (!parsed)
+            continue;
+        if (normalizedWorkDir) {
+            const normalizedSessionDir = normalizeCursorPath(sessionDir);
+            const isWorkDirLocalSession = normalizedWorkDirSessionRoot
+                && (normalizedSessionDir === normalizedWorkDirSessionRoot || normalizedSessionDir.startsWith(`${normalizedWorkDirSessionRoot}/`));
+            const effectiveProjectPath = parsed.projectPath || (isWorkDirLocalSession ? workDir || '' : '');
+            if (!effectiveProjectPath || normalizeCursorPath(effectiveProjectPath) !== normalizedWorkDir)
+                continue;
+            if (!parsed.projectPath) {
+                parsed.projectPath = effectiveProjectPath;
+                parsed.projectFolder = effectiveProjectPath.replace(/[\\/]+$/, '').split(/[\\/]/).pop() || effectiveProjectPath;
+            }
+        }
+        entries.push({
+            session: parsed,
+            sortKey: { lastModified: parsed.lastModified, sessionId: parsed.sessionId, tieBreaker: normalizeCursorPath(sessionDir) },
+        });
+    }
+    entries.sort((a, b) => compareCursorSortKeys(a.sortKey, b.sortKey));
+    return entries;
+}
+export function listYeaftSessions(workDir) {
+    return listYeaftSessionsPage(workDir, { limit: Number.POSITIVE_INFINITY }).sessions;
+}
+export function listYeaftSessionsPage(workDir, options = {}) {
+    const entries = getYeaftSessionEntries(workDir);
+    const limit = normalizeSessionLimit(options.limit);
+    let startIndex = 0;
+    if (options.cursor) {
+        const cursor = decodeYeaftCursor(options.cursor, 'workdir', workDir);
+        startIndex = entries.findIndex(entry => compareCursorSortKeys(entry.sortKey, cursor) > 0);
+        if (startIndex < 0)
+            return { sessions: [], hasMore: false };
+    }
+    const pageEntries = limit === Number.POSITIVE_INFINITY ? entries.slice(startIndex) : entries.slice(startIndex, startIndex + limit);
+    const nextIndex = startIndex + pageEntries.length;
+    const hasMore = nextIndex < entries.length;
+    return {
+        sessions: pageEntries.map(({ session }) => ({ sessionId: session.sessionId, title: session.title, customTitle: session.customTitle, preview: session.preview, lastModified: session.lastModified })),
+        hasMore,
+        ...(hasMore ? { nextCursor: encodeYeaftCursor('workdir', entries[nextIndex - 1].sortKey, workDir) } : {}),
+    };
+}
+export function listAllYeaftSessionsPage(options = {}) {
+    const entries = getYeaftSessionEntries();
+    const limit = normalizeSessionLimit(options.limit);
+    let startIndex = 0;
+    if (options.cursor) {
+        const cursor = decodeYeaftCursor(options.cursor, 'global');
+        startIndex = entries.findIndex(entry => compareCursorSortKeys(entry.sortKey, cursor) > 0);
+        if (startIndex < 0)
+            return { sessions: [], hasMore: false, indexState: 'ready' };
+    }
+    const pageEntries = limit === Number.POSITIVE_INFINITY ? entries.slice(startIndex) : entries.slice(startIndex, startIndex + limit);
+    const nextIndex = startIndex + pageEntries.length;
+    const hasMore = nextIndex < entries.length;
+    return {
+        sessions: pageEntries.map(({ session }) => ({ sessionId: session.sessionId, projectPath: session.projectPath, projectFolder: session.projectFolder, title: session.title, firstPrompt: session.firstPrompt, lastModified: session.lastModified })),
+        hasMore,
+        ...(hasMore ? { nextCursor: encodeYeaftCursor('global', entries[nextIndex - 1].sortKey) } : {}),
+        indexState: 'ready',
+    };
+}
+export function listAllYeaftSessions() {
+    return listAllYeaftSessionsPage({ limit: Number.POSITIVE_INFINITY }).sessions;
+}
+function findYeaftSessionDir(workDir, sessionId) {
+    for (const dir of listYeaftSessionDirs(workDir)) {
+        if (dir.replace(/\\/g, '/').split('/').pop() === sessionId)
+            return dir;
+    }
+    return null;
+}
+export function readYeaftSessionMessages(workDir, sessionId) {
+    const dir = findYeaftSessionDir(workDir, sessionId);
+    if (!dir)
+        return [];
+    const messages = [];
+    const seenMessages = new Set();
+    const seenUserPrompts = new Set();
+    const toolCallsById = new Map();
+    for (const row of readSessionRows(dir)) {
+        const role = textFromUnknown(row.role) || (row.from === 'user' ? 'user' : '');
+        const content = rowText(row);
+        if (!shouldShowYeaftConversationRow(row, role, content))
+            continue;
+        const timestamp = rowTimestamp(row);
+        const vpId = rowVpId(row);
+        const threadId = rowThreadId(row);
+        if (role === 'assistant' && Array.isArray(row.toolCalls)) {
+            for (const value of row.toolCalls) {
+                if (!value || typeof value !== 'object')
+                    continue;
+                const tool = value;
+                const id = textFromUnknown(tool.id) || textFromUnknown(tool.toolCallId);
+                if (!id)
+                    continue;
+                toolCallsById.set(id, {
+                    name: textFromUnknown(tool.name) || textFromUnknown(tool.toolName) || undefined,
+                    input: tool.input,
+                    ...(vpId ? { vpId } : {}),
+                    ...(threadId ? { threadId } : {}),
+                });
+            }
+        }
+        if (role === 'user') {
+            const key = userPromptKey(content, row);
+            if (seenUserPrompts.has(key))
+                continue;
+            seenUserPrompts.add(key);
+            pushUniqueHistoryMessage(messages, seenMessages, { role: 'user', content, timestamp });
+        }
+        else if (role === 'assistant' && content) {
+            pushUniqueHistoryMessage(messages, seenMessages, {
+                role: 'assistant',
+                content,
+                timestamp,
+                providerId: 'yeaft',
+                ...(vpId ? { vpId } : {}),
+                ...(threadId ? { threadId } : {}),
+            });
+        }
+        else if (role === 'tool') {
+            const toolId = textFromUnknown(row.toolCallId) || textFromUnknown(row.tool_call_id) || textFromUnknown(row.tool_use_id) || textFromUnknown(row.toolId);
+            const call = toolId ? toolCallsById.get(toolId) : undefined;
+            pushUniqueHistoryMessage(messages, seenMessages, {
+                role: 'tool',
+                content: '',
+                toolId,
+                toolName: textFromUnknown(row.name) || textFromUnknown(row.toolName) || call?.name,
+                toolInput: stringifyMaybe(row.input ?? call?.input),
+                toolOutput: textFromUnknown(row.output) || textFromUnknown(row.toolOutput) || textFromUnknown(row.content),
+                timestamp,
+                providerId: 'yeaft',
+                ...(vpId || call?.vpId ? { vpId: vpId || call?.vpId } : {}),
+                ...(threadId || call?.threadId ? { threadId: threadId || call?.threadId } : {}),
+            });
+        }
+    }
+    return messages;
+}
+function stringifyMaybe(value) {
+    if (value == null)
+        return undefined;
+    if (typeof value === 'string')
+        return value;
+    try {
+        return JSON.stringify(value, null, 2);
+    }
+    catch {
+        return String(value);
+    }
+}
+export function renameYeaftSession(workDir, sessionId, newTitle) {
+    if (!findYeaftSessionDir(workDir, sessionId))
+        return false;
+    setCustomTitle(sessionId, newTitle);
+    return true;
+}
+export function deleteYeaftSession(workDir, sessionId) {
+    const dir = findYeaftSessionDir(workDir, sessionId);
+    if (!dir)
+        return false;
+    try {
+        rmSync(dir, { recursive: true, force: true });
+        removeCustomTitle(sessionId);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function moveYeaftSession(fromWorkDir, toWorkDir, sessionId) {
+    const source = findYeaftSessionDir(fromWorkDir, sessionId);
+    if (!source)
+        return false;
+    const destRoot = join(toWorkDir, '.yeaft', 'sessions');
+    const dest = join(destRoot, sessionId);
+    if (existsSync(dest))
+        return false;
+    try {
+        mkdirSync(destRoot, { recursive: true });
+        rmSync(dest, { recursive: true, force: true });
+        // Use copy+remove to work across volumes.
+        copyDir(source, dest);
+        updateMovedSessionWorkDir(dest, toWorkDir);
+        rmSync(source, { recursive: true, force: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function copyDir(source, dest) {
+    mkdirSync(dest, { recursive: true });
+    for (const entry of readdirSync(source, { withFileTypes: true })) {
+        const src = join(source, entry.name);
+        const dst = join(dest, entry.name);
+        if (entry.isDirectory())
+            copyDir(src, dst);
+        else
+            writeFileSync(dst, readFileSync(src));
+    }
+}
+function updateMovedSessionWorkDir(sessionDir, workDir) {
+    for (const name of ['session.json', 'group.json']) {
+        const filePath = join(sessionDir, name);
+        const meta = readJsonObject(filePath);
+        if (!meta)
+            continue;
+        meta.workDir = workDir;
+        try {
+            writeFileSync(filePath, JSON.stringify(meta, null, 2) + '\n', 'utf-8');
+        }
+        catch { /* ignore */ }
+        return;
+    }
+}
+export { yeaftCapabilities };
+//# sourceMappingURL=yeaft.js.map