@kienmatu/inkos-core 0.1.0

package/dist/interaction/session-transcript-restore.js

@@ -0,0 +1,746 @@
+import { readTranscriptEvents } from "./session-transcript.js";
+import { BookSessionSchema, } from "./session.js";
+function isObject(value) {
+    return !!value && typeof value === "object";
+}
+function contentBlocks(message) {
+    return Array.isArray(message.content) ? message.content : [];
+}
+function hasTextContent(message) {
+    return contentBlocks(message).some((block) => isObject(block) &&
+        block.type === "text" &&
+        typeof block.text === "string" &&
+        block.text.length > 0);
+}
+function hasToolCallContent(message) {
+    return contentBlocks(message).some((block) => isObject(block) && block.type === "toolCall" && typeof block.id === "string");
+}
+function toolCallIds(message) {
+    return contentBlocks(message)
+        .filter((block) => isObject(block) && block.type === "toolCall" && typeof block.id === "string")
+        .map((block) => block.id);
+}
+function isThinkingBlock(block) {
+    return isObject(block) && (block.type === "thinking" || block.type === "redacted_thinking");
+}
+function removeTrailingThinking(message) {
+    if (!isObject(message) || message.role !== "assistant" || !Array.isArray(message.content)) {
+        return message;
+    }
+    const content = [...message.content];
+    while (content.length > 0 && isThinkingBlock(content[content.length - 1])) {
+        content.pop();
+    }
+    if (content.length === message.content.length)
+        return message;
+    return { ...message, content };
+}
+const emptyUsage = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens: 0,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+};
+export const TOOL_RESULT_BRIDGE_TEXT = "I have processed the tool results.";
+const MAX_RESTORED_DIALOGUE_MESSAGES = 12;
+const MAX_RESTORED_TOOL_SUMMARY_ITEMS = 8;
+const EXPIRED_SKILL_RESULT_TEXT = "Skill instructions expired after their original turn.";
+const RESTORED_HISTORY_BOUNDARY_ZH = "[已完成的历史上下文]\n" +
+    "以上是已经完成并提交的历史上下文，只能用于回忆，不代表当前轮已经执行了动作。\n" +
+    "当前轮必须优先遵循用户接下来输入的最新指令；如果最新输入是提问、讨论或确认，直接回答，不要因为历史工具结果跳过判断或继续执行旧动作。";
+const RESTORED_HISTORY_BOUNDARY_EN = "[Completed history context]\n" +
+    "The messages above are completed and committed history. Use them only as memory; they do not mean any action has already run in the current turn.\n" +
+    "For the current turn, prioritize the next user instruction. If it is a question, discussion, or confirmation, answer directly instead of continuing an old tool action.";
+function toolResultBridgeMessage(timestamp) {
+    return {
+        role: "assistant",
+        content: [{ type: "text", text: TOOL_RESULT_BRIDGE_TEXT }],
+        api: "openai-completions",
+        provider: "inkos",
+        model: "synthetic-tool-result-bridge",
+        usage: emptyUsage,
+        stopReason: "stop",
+        timestamp,
+    };
+}
+function addToolResultBridges(messages) {
+    const bridged = [];
+    for (let i = 0; i < messages.length; i++) {
+        const message = messages[i];
+        bridged.push(message);
+        if (!isObject(message) || message.role !== "toolResult")
+            continue;
+        const next = messages[i + 1];
+        if (isObject(next) && (next.role === "toolResult" || next.role === "assistant"))
+            continue;
+        const timestamp = typeof message.timestamp === "number" ? message.timestamp + 1 : Date.now();
+        bridged.push(toolResultBridgeMessage(timestamp));
+    }
+    return bridged;
+}
+function systemMessage(content, timestamp) {
+    return {
+        role: "system",
+        content,
+        timestamp,
+    };
+}
+export function appendRestoredHistoryBoundary(messages, language) {
+    if (messages.length === 0)
+        return messages;
+    const timestamp = messages.reduce((max, message) => {
+        if (isObject(message) && typeof message.timestamp === "number") {
+            return Math.max(max, message.timestamp);
+        }
+        return max;
+    }, 0) || Date.now();
+    return [
+        ...messages,
+        systemMessage(language === "zh" ? RESTORED_HISTORY_BOUNDARY_ZH : RESTORED_HISTORY_BOUNDARY_EN, timestamp + 1),
+    ];
+}
+export function cleanRestoredAgentMessages(messages) {
+    const availableToolCalls = new Set();
+    for (const message of messages) {
+        if (isObject(message) && message.role === "assistant") {
+            for (const id of toolCallIds(message))
+                availableToolCalls.add(id);
+        }
+    }
+    const cleaned = messages.filter((message) => {
+        if (!isObject(message))
+            return false;
+        if (message.role === "toolResult") {
+            return typeof message.toolCallId === "string" && availableToolCalls.has(message.toolCallId);
+        }
+        if (message.role === "assistant") {
+            return hasTextContent(message) || hasToolCallContent(message);
+        }
+        return message.role === "user" || message.role === "system";
+    });
+    if (cleaned.length === 0)
+        return cleaned;
+    const last = cleaned[cleaned.length - 1];
+    if (isObject(last) && last.role === "assistant") {
+        cleaned[cleaned.length - 1] = removeTrailingThinking(last);
+    }
+    return cleaned;
+}
+function requiresAssistantAfterToolResult(target) {
+    return !!(target.compat &&
+        typeof target.compat === "object" &&
+        target.compat.requiresAssistantAfterToolResult === true);
+}
+function isSameAssistantModel(message, target) {
+    return (typeof message.api === "string" &&
+        typeof message.provider === "string" &&
+        typeof message.model === "string" &&
+        message.api === target.api &&
+        message.provider === target.provider &&
+        message.model === target.id);
+}
+export function adaptRestoredAgentMessagesForModel(messages, target) {
+    const adapted = [];
+    const pushToolResultsAsSystem = (toolResults) => {
+        const lines = toolResults.flatMap((message) => {
+            const raw = isObject(message) ? message : {};
+            const toolName = typeof raw.toolName === "string" ? raw.toolName : "tool";
+            const toolCallId = typeof raw.toolCallId === "string" ? raw.toolCallId : "unknown";
+            const text = contentBlocks(raw)
+                .map((block) => {
+                if (isObject(block) && block.type === "text" && typeof block.text === "string") {
+                    return block.text;
+                }
+                return "";
+            })
+                .filter(Boolean)
+                .join("\n")
+                .trim() || "(empty tool result)";
+            return [`- ${toolName} (${toolCallId}):`, text];
+        });
+        const timestamp = toolResults.reduce((max, message) => {
+            if (isObject(message) && typeof message.timestamp === "number") {
+                return Math.max(max, message.timestamp);
+            }
+            return max;
+        }, 0) || Date.now();
+        adapted.push(systemMessage([
+            "[Historical tool results]",
+            "These are completed historical tool results. They are state context, not a new user request.",
+            ...lines,
+        ].join("\n"), timestamp));
+    };
+    for (let index = 0; index < messages.length; index++) {
+        const message = messages[index];
+        if (!isObject(message))
+            continue;
+        if (message.role === "assistant") {
+            const content = contentBlocks(message);
+            const isBridge = content.length === 1 &&
+                isObject(content[0]) &&
+                content[0].type === "text" &&
+                typeof content[0].text === "string" &&
+                content[0].text.trim() === TOOL_RESULT_BRIDGE_TEXT;
+            const previous = adapted[adapted.length - 1];
+            const previousRole = isObject(previous)
+                ? previous.role
+                : undefined;
+            if (isBridge &&
+                isObject(previous) &&
+                (previousRole === "user" || previousRole === "system") &&
+                typeof previous.content === "string" &&
+                (previous.content.startsWith("[Tool results]") || previous.content.startsWith("[Historical tool results]"))) {
+                continue;
+            }
+            const contentWithoutThinking = content.filter((block) => !isThinkingBlock(block));
+            const foreignToolCallIds = new Set(contentWithoutThinking
+                .filter((block) => isObject(block) && block.type === "toolCall" && typeof block.id === "string")
+                .map((block) => block.id));
+            if (foreignToolCallIds.size === 0) {
+                if (Array.isArray(message.content) && isSameAssistantModel(message, target)) {
+                    adapted.push(message);
+                    continue;
+                }
+                const rewritten = contentWithoutThinking.length === content.length
+                    ? message
+                    : { ...message, content: contentWithoutThinking };
+                if (contentWithoutThinking.some((block) => isObject(block) &&
+                    block.type === "text" &&
+                    typeof block.text === "string" &&
+                    block.text.length > 0)) {
+                    adapted.push(rewritten);
+                }
+                continue;
+            }
+            const textContent = contentWithoutThinking.filter((block) => isObject(block) &&
+                block.type === "text" &&
+                typeof block.text === "string" &&
+                block.text.trim().length > 0);
+            if (textContent.length > 0) {
+                adapted.push({ ...message, content: textContent });
+            }
+            const toolResults = [];
+            let nextIndex = index + 1;
+            while (nextIndex < messages.length) {
+                const next = messages[nextIndex];
+                if (!isObject(next) ||
+                    next.role !== "toolResult" ||
+                    typeof next.toolCallId !== "string" ||
+                    !foreignToolCallIds.has(next.toolCallId)) {
+                    break;
+                }
+                toolResults.push(next);
+                nextIndex += 1;
+            }
+            if (toolResults.length > 0) {
+                pushToolResultsAsSystem(toolResults);
+                index = nextIndex - 1;
+            }
+            continue;
+        }
+        if (message.role === "toolResult") {
+            pushToolResultsAsSystem([message]);
+            continue;
+        }
+        adapted.push(message);
+    }
+    const filtered = adapted.filter((message) => {
+        if (!isObject(message) || message.role !== "assistant")
+            return true;
+        return hasTextContent(message) || hasToolCallContent(message);
+    });
+    return requiresAssistantAfterToolResult(target)
+        ? addToolResultBridges(filtered)
+        : filtered;
+}
+export function committedMessageEvents(events, sessionKind) {
+    const requestKinds = new Map(events
+        .filter((event) => event.type === "request_started")
+        .map((event) => [event.requestId, event.sessionKind]));
+    const committed = new Set(events
+        .filter((event) => event.type === "request_committed")
+        .filter((event) => {
+        if (!sessionKind)
+            return true;
+        const kind = requestKinds.get(event.requestId);
+        return kind === undefined || kind === sessionKind;
+    })
+        .map((event) => event.requestId));
+    return events
+        .filter((event) => event.type === "message" && committed.has(event.requestId))
+        .sort((a, b) => a.seq - b.seq);
+}
+function requestKindMap(events) {
+    return new Map(events
+        .filter((event) => event.type === "request_started")
+        .map((event) => [event.requestId, event.sessionKind]));
+}
+function textOnlyAgentMessage(event) {
+    const raw = event.message;
+    if (!isObject(raw) || event.role === "toolResult")
+        return null;
+    if (event.role === "user" || event.role === "system") {
+        const content = textFromContent(raw.content);
+        return content ? { role: event.role, content, timestamp: event.timestamp } : null;
+    }
+    if (event.role === "assistant") {
+        const textBlocks = contentBlocks(raw).filter((block) => isObject(block) &&
+            block.type === "text" &&
+            typeof block.text === "string" &&
+            block.text.trim().length > 0);
+        if (textBlocks.length === 0)
+            return null;
+        return {
+            ...raw,
+            role: "assistant",
+            content: textBlocks,
+            timestamp: event.timestamp,
+        };
+    }
+    return null;
+}
+function buildHistoricalToolSummary(events, sessionKind) {
+    const kinds = requestKindMap(events);
+    const committed = committedMessageEvents(events, sessionKind);
+    const calls = new Map();
+    const summaries = [];
+    for (const event of committed) {
+        const requestKind = kinds.get(event.requestId);
+        if (sessionKind && requestKind !== sessionKind) {
+            continue;
+        }
+        const raw = event.message;
+        if (!isObject(raw))
+            continue;
+        if (event.role === "assistant") {
+            for (const block of contentBlocks(raw)) {
+                if (!isObject(block) || block.type !== "toolCall")
+                    continue;
+                const id = typeof block.id === "string" ? block.id : "";
+                if (!id)
+                    continue;
+                const tool = typeof block.name === "string" && block.name ? block.name : "tool";
+                const args = isObject(block.arguments) ? block.arguments : undefined;
+                const agent = typeof args?.agent === "string" ? args.agent : undefined;
+                calls.set(`${event.requestId}\0${id}`, {
+                    tool,
+                    ...(agent ? { agent } : {}),
+                    timestamp: event.timestamp,
+                });
+            }
+            continue;
+        }
+        if (event.role !== "toolResult")
+            continue;
+        const toolCallId = typeof raw.toolCallId === "string"
+            ? raw.toolCallId
+            : event.toolCallId ?? "";
+        const call = calls.get(`${event.requestId}\0${toolCallId}`);
+        const tool = typeof raw.toolName === "string" && raw.toolName
+            ? raw.toolName
+            : call?.tool ?? "tool";
+        const agent = call?.agent;
+        const status = raw.isError === true ? "failed" : "completed";
+        const text = tool === "use_skill"
+            ? "expired; instructions are not active for later turns"
+            : textFromContent(raw.content).replace(/\s+/g, " ").trim();
+        const trimmed = text.length > 180 ? `${text.slice(0, 180)}...` : text;
+        summaries.push({
+            timestamp: event.timestamp,
+            line: `- ${tool}${agent ? `:${agent}` : ""} ${status}${trimmed ? ` — ${trimmed}` : ""}`,
+        });
+    }
+    if (summaries.length === 0)
+        return null;
+    const latest = summaries.slice(-MAX_RESTORED_TOOL_SUMMARY_ITEMS);
+    const timestamp = latest.reduce((max, item) => Math.max(max, item.timestamp), 0) || Date.now();
+    return systemMessage([
+        "[历史状态摘要]",
+        "以下是已经完成的历史工具动作摘要，只说明当前状态；不是当前用户的新指令，也不表示本轮已经执行。",
+        ...latest.map((item) => item.line),
+    ].join("\n"), timestamp);
+}
+function requestIdsWithToolActivity(events) {
+    const ids = new Set();
+    for (const event of events) {
+        if (event.role === "toolResult") {
+            ids.add(event.requestId);
+            continue;
+        }
+        const raw = event.message;
+        if (!isObject(raw))
+            continue;
+        if (contentBlocks(raw).some((block) => isObject(block) && block.type === "toolCall")) {
+            ids.add(event.requestId);
+        }
+    }
+    return ids;
+}
+function requestIdsUsingSkill(events) {
+    const ids = new Set();
+    for (const event of events) {
+        if (event.role !== "assistant")
+            continue;
+        const raw = event.message;
+        if (!isObject(raw))
+            continue;
+        if (contentBlocks(raw).some((block) => (isObject(block)
+            && block.type === "toolCall"
+            && block.name === "use_skill"))) {
+            ids.add(event.requestId);
+        }
+    }
+    return ids;
+}
+export async function restoreAgentMessagesFromTranscript(projectRoot, sessionId, sessionKind) {
+    const events = await readTranscriptEvents(projectRoot, sessionId);
+    const summary = buildHistoricalToolSummary(events, sessionKind);
+    const committed = committedMessageEvents(events, sessionKind);
+    const toolRequestIds = requestIdsWithToolActivity(committed);
+    const kinds = requestKindMap(events);
+    const dialogue = committed
+        .filter((event) => {
+        if (!toolRequestIds.has(event.requestId))
+            return true;
+        // Legacy events have no sessionKind. Keep the user's own words as
+        // conversation memory, but do not replay the old tool call/result.
+        return Boolean(sessionKind && kinds.get(event.requestId) === undefined && event.role === "user");
+    })
+        .map((event) => textOnlyAgentMessage(event))
+        .filter((message) => message !== null)
+        .slice(-MAX_RESTORED_DIALOGUE_MESSAGES);
+    return [
+        ...(summary ? [summary] : []),
+        ...dialogue,
+    ];
+}
+function textFromContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .filter((block) => isObject(block) && block.type === "text" && typeof block.text === "string")
+        .map((block) => block.text)
+        .join("");
+}
+function thinkingFromContent(content) {
+    if (!Array.isArray(content))
+        return undefined;
+    const value = content
+        .filter((block) => isObject(block) && block.type === "thinking")
+        .map((block) => typeof block.thinking === "string" ? block.thinking : "")
+        .join("");
+    return value || undefined;
+}
+function joinThinking(parts) {
+    const values = parts
+        .map((part) => part?.trim() ?? "")
+        .filter((part) => part.length > 0);
+    return values.length > 0 ? values.join("\n\n---\n\n") : undefined;
+}
+function firstUserMessageTitle(messages) {
+    for (const message of messages) {
+        if (message.role !== "user")
+            continue;
+        const oneLine = message.content.trim().replace(/\s+/g, " ");
+        if (!oneLine)
+            return null;
+        return oneLine.length > 20 ? `${oneLine.slice(0, 20)}…` : oneLine;
+    }
+    return null;
+}
+function messageEventToInteractionMessage(event, restoredToolExecutions, restoredThinking, options = {}) {
+    const raw = event.message;
+    if (!isObject(raw))
+        return null;
+    if (event.role === "toolResult")
+        return null;
+    if (event.role === "user") {
+        const content = textFromContent(raw.content);
+        return content ? { role: "user", content, timestamp: event.timestamp } : null;
+    }
+    if (event.role === "assistant") {
+        const rawText = textFromContent(raw.content);
+        const content = options.suppressAssistantText ? "" : rawText;
+        const thinking = options.suppressThinking
+            ? undefined
+            : joinThinking([
+                ...(restoredThinking ?? []),
+                thinkingFromContent(raw.content),
+                event.legacyDisplay?.thinking,
+                options.suppressAssistantText ? rawText : undefined,
+            ]);
+        const toolExecutions = restoredToolExecutions?.length
+            ? restoredToolExecutions
+            : event.legacyDisplay?.toolExecutions;
+        if (!content && !thinking && !toolExecutions?.length)
+            return null;
+        if (!content && !toolExecutions?.length)
+            return null;
+        return {
+            role: "assistant",
+            content,
+            ...(thinking ? { thinking } : {}),
+            ...(toolExecutions?.length ? { toolExecutions } : {}),
+            timestamp: event.timestamp,
+        };
+    }
+    if (event.role === "system") {
+        const content = textFromContent(raw.content);
+        return content ? { role: "system", content, timestamp: event.timestamp } : null;
+    }
+    return null;
+}
+function messageEventsToInteractionMessages(events) {
+    const agentLabels = {
+        architect: "建书",
+        writer: "写作",
+        auditor: "审计",
+        reviser: "修订",
+        exporter: "导出",
+    };
+    const toolLabels = {
+        read: "读取文件",
+        edit: "编辑文件",
+        grep: "搜索",
+        ls: "列目录",
+        propose_action: "确认动作",
+        short_fiction_run: "短篇生产",
+        generate_cover: "生成封面",
+        play_edit: "编辑互动世界",
+        play_start: "启动互动世界",
+        play_revise: "重做互动回合",
+        play_step: "推进互动世界",
+        create_narrative_forecast: "剧情多线推演",
+        get_narrative_forecast: "核验剧情推演",
+        select_narrative_branch: "采用候选分支",
+    };
+    const messages = [];
+    const toolCalls = new Map();
+    const skillRequestIds = requestIdsUsingSkill(events);
+    let pendingToolExecutions = [];
+    let pendingThinking = [];
+    let activeRequestId = null;
+    const clearPending = () => {
+        pendingToolExecutions = [];
+        pendingThinking = [];
+    };
+    const flushPendingToolExecutions = () => {
+        if (pendingToolExecutions.length === 0)
+            return;
+        const last = messages[messages.length - 1];
+        const thinking = joinThinking(pendingThinking);
+        if (last?.role === "assistant") {
+            messages[messages.length - 1] = {
+                ...last,
+                ...(thinking ? { thinking: joinThinking([last.thinking, thinking]) } : {}),
+                toolExecutions: [
+                    ...(last.toolExecutions ?? []),
+                    ...pendingToolExecutions,
+                ],
+            };
+        }
+        else {
+            messages.push({
+                role: "assistant",
+                content: "",
+                ...(thinking ? { thinking } : {}),
+                toolExecutions: pendingToolExecutions,
+                timestamp: pendingToolExecutions.reduce((latest, execution) => Math.max(latest, execution.completedAt ?? execution.startedAt), 0),
+            });
+        }
+        clearPending();
+    };
+    const toolCallKey = (requestId, toolCallId) => `${requestId}\0${toolCallId}`;
+    const objectArgs = (value) => {
+        if (isObject(value))
+            return value;
+        if (typeof value !== "string" || !value.trim())
+            return undefined;
+        try {
+            const parsed = JSON.parse(value);
+            return isObject(parsed) ? parsed : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const resolveToolLabel = (tool, agent) => {
+        if (tool === "sub_agent" && agent)
+            return agentLabels[agent] ?? agent;
+        return toolLabels[tool] ?? tool;
+    };
+    const hasCompletedPlayTool = (executions) => executions.some((execution) => execution.status === "completed"
+        && (execution.tool === "play_start" || execution.tool === "play_step" || execution.tool === "play_revise"));
+    const rememberToolCalls = (event, raw) => {
+        for (const block of contentBlocks(raw)) {
+            if (!isObject(block) || block.type !== "toolCall")
+                continue;
+            if (typeof block.id !== "string" || !block.id)
+                continue;
+            const tool = typeof block.name === "string" && block.name ? block.name : "tool";
+            const args = objectArgs(block.arguments);
+            toolCalls.set(toolCallKey(event.requestId, block.id), {
+                id: block.id,
+                tool,
+                ...(args ? { args } : {}),
+                timestamp: event.timestamp,
+            });
+        }
+    };
+    const toolExecutionFromResult = (event) => {
+        const raw = event.message;
+        if (!isObject(raw))
+            return null;
+        const toolCallId = typeof raw.toolCallId === "string"
+            ? raw.toolCallId
+            : typeof event.toolCallId === "string"
+                ? event.toolCallId
+                : "";
+        if (!toolCallId)
+            return null;
+        const call = toolCalls.get(toolCallKey(event.requestId, toolCallId));
+        const tool = typeof raw.toolName === "string" && raw.toolName
+            ? raw.toolName
+            : call?.tool ?? "tool";
+        const args = call?.args;
+        const agent = tool === "sub_agent" && typeof args?.agent === "string"
+            ? args.agent
+            : undefined;
+        const text = textFromContent(raw.content).trim();
+        const isError = raw.isError === true;
+        const details = raw.details;
+        const expiredSkill = tool === "use_skill";
+        return {
+            id: toolCallId,
+            tool,
+            ...(agent ? { agent } : {}),
+            label: resolveToolLabel(tool, agent),
+            status: isError ? "error" : "completed",
+            ...(args ? { args } : {}),
+            ...(isError
+                ? { error: text.slice(0, 500) || "Tool execution failed" }
+                : expiredSkill
+                    ? { result: EXPIRED_SKILL_RESULT_TEXT }
+                    : text
+                        ? { result: text.slice(0, 200) }
+                        : {}),
+            ...(expiredSkill
+                ? { details: { kind: "skill_expired" } }
+                : details !== undefined
+                    ? { details }
+                    : {}),
+            startedAt: call?.timestamp ?? event.timestamp,
+            completedAt: event.timestamp,
+        };
+    };
+    for (const event of events) {
+        const raw = event.message;
+        if (activeRequestId !== event.requestId) {
+            flushPendingToolExecutions();
+            activeRequestId = event.requestId;
+            clearPending();
+        }
+        if (event.role === "assistant" && isObject(raw)) {
+            rememberToolCalls(event, raw);
+            const isSkillRequest = skillRequestIds.has(event.requestId);
+            const currentThinking = isSkillRequest ? undefined : thinkingFromContent(raw.content);
+            const currentText = textFromContent(raw.content).trim();
+            const legacyToolExecutions = event.legacyDisplay?.toolExecutions;
+            const hasLegacyDisplay = !!currentThinking
+                || (!isSkillRequest && !!event.legacyDisplay?.thinking)
+                || !!legacyToolExecutions?.length;
+            if (pendingToolExecutions.length > 0
+                && !hasCompletedPlayTool(pendingToolExecutions)
+                && !currentText
+                && !currentThinking
+                && !hasToolCallContent(raw)
+                && !hasLegacyDisplay) {
+                // Empty terminal assistant messages only close the model turn. Keep
+                // non-play tool results pending so they attach to the previous prose
+                // message; play results are intentionally restored as standalone cards.
+                continue;
+            }
+            const message = messageEventToInteractionMessage(event, pendingToolExecutions.length > 0 ? pendingToolExecutions : undefined, pendingThinking.length > 0 ? pendingThinking : undefined, {
+                suppressAssistantText: hasCompletedPlayTool(pendingToolExecutions),
+                suppressThinking: isSkillRequest,
+            });
+            if (message) {
+                messages.push(message);
+                clearPending();
+            }
+            else if (hasToolCallContent(raw) && currentThinking) {
+                pendingThinking.push(currentThinking);
+            }
+            continue;
+        }
+        if (event.role === "toolResult") {
+            const execution = toolExecutionFromResult(event);
+            if (execution)
+                pendingToolExecutions.push(execution);
+            continue;
+        }
+        clearPending();
+        const message = messageEventToInteractionMessage(event);
+        if (message)
+            messages.push(message);
+    }
+    flushPendingToolExecutions();
+    return messages;
+}
+export async function deriveBookSessionFromTranscript(projectRoot, sessionId) {
+    const events = await readTranscriptEvents(projectRoot, sessionId);
+    if (events.length === 0)
+        return null;
+    const created = events.find((event) => event.type === "session_created");
+    let bookId = created?.type === "session_created" ? created.bookId : null;
+    let sessionKind = created?.type === "session_created" ? created.sessionKind : undefined;
+    let playMode = created?.type === "session_created" ? created.playMode : undefined;
+    let title = created?.type === "session_created" ? created.title : null;
+    const createdAt = created?.type === "session_created"
+        ? created.createdAt
+        : events[0]?.timestamp ?? Date.now();
+    const latestActivityTimestamp = events.reduce((max, event) => {
+        if (event.type === "session_created" || event.type === "session_metadata_updated") {
+            return Math.max(max, event.updatedAt);
+        }
+        return Math.max(max, event.timestamp);
+    }, 0);
+    let updatedAt = created?.type === "session_created"
+        ? created.updatedAt
+        : events[events.length - 1]?.timestamp ?? createdAt;
+    updatedAt = Math.max(updatedAt, latestActivityTimestamp);
+    for (const event of events) {
+        if (event.type !== "session_metadata_updated")
+            continue;
+        if ("bookId" in event && event.bookId !== undefined)
+            bookId = event.bookId;
+        if ("sessionKind" in event && event.sessionKind !== undefined)
+            sessionKind = event.sessionKind;
+        if ("playMode" in event && event.playMode !== undefined)
+            playMode = event.playMode;
+        if ("title" in event && event.title !== undefined)
+            title = event.title;
+        updatedAt = Math.max(updatedAt, event.updatedAt);
+    }
+    const messages = messageEventsToInteractionMessages(committedMessageEvents(events));
+    if (title === null) {
+        title = firstUserMessageTitle(messages);
+    }
+    return BookSessionSchema.parse({
+        sessionId,
+        bookId,
+        sessionKind,
+        playMode,
+        title,
+        messages,
+        draftRounds: [],
+        events: [],
+        createdAt,
+        updatedAt,
+    });
+}
+//# sourceMappingURL=session-transcript-restore.js.map