@beeuni/sdk 0.1.0 → 0.2.0

package/dist/core/session-log/v1-view.js

@@ -0,0 +1,151 @@
+import { SESSION_LOG_MINOR, SESSION_LOG_SCHEMA } from './types.js';
+import { BEEUNI_TRANSCRIPT_SCHEMA } from '../runtime/transcript-types.js';
+import { fromV1, toV1 } from './v1.js';
+const SHELL = {
+    schema: SESSION_LOG_SCHEMA,
+    v: SESSION_LOG_MINOR,
+    session_id: '',
+    title: null,
+    created_at: '',
+    restore_grade: 'native',
+    harness: { current: '', history: [] },
+    selection: { agent: null, model: null },
+    todos: [],
+    pending: { questions: [], permissions: [] },
+};
+const NO_MESSAGES = [];
+const v1Ext = (head) => Object.values(head.ext ?? {}).find((e) => e.version === BEEUNI_TRANSCRIPT_SCHEMA);
+export const isV1Thread = (head) => !!head && v1Ext(head) !== undefined;
+const nativeOf = (head) => {
+    const e = v1Ext(head);
+    return e ? (e.native_id ?? null) : head.thread_id;
+};
+const messageRows = new WeakMap();
+function rowsOf(head, message) {
+    const native = nativeOf(head);
+    const cached = messageRows.get(message);
+    if (cached && cached.native === native)
+        return cached.rows;
+    const { rows } = toV1({ ...SHELL, threads: [{ ...head, messages: [message] }] });
+    const out = rows.map((r) => ({ info: r.info, parts: r.parts }));
+    messageRows.set(message, { native, rows: out });
+    return out;
+}
+const indexes = new WeakMap();
+function indexOf(state) {
+    let index = indexes.get(state);
+    if (!index) {
+        index = new Map();
+        for (const head of Object.values(state.threads)) {
+            const native = v1Ext(head) ? nativeOf(head) : null;
+            if (native !== null && !index.has(native))
+                index.set(native, head.thread_id);
+        }
+        indexes.set(state, index);
+    }
+    return index;
+}
+function findThread(logs, runtimeSessionId) {
+    for (const state of Object.values(logs)) {
+        const threadId = indexOf(state).get(runtimeSessionId);
+        if (threadId !== undefined)
+            return { state, head: state.threads[threadId], list: state.messages[threadId] ?? NO_MESSAGES };
+    }
+    return null;
+}
+const createdOf = (row) => row.info.time?.created;
+function insertAt(rows, row) {
+    const created = createdOf(row);
+    if (created === undefined)
+        return rows.length;
+    const at = rows.findIndex((other) => {
+        const t = createdOf(other);
+        return t !== undefined && (t > created || (t === created && other.info.id > row.info.id));
+    });
+    return at < 0 ? rows.length : at;
+}
+const v1Order = (a, b) => (createdOf(a) ?? -Infinity) - (createdOf(b) ?? -Infinity) || (a.info.id < b.info.id ? -1 : a.info.id > b.info.id ? 1 : 0);
+const merged = new WeakMap();
+export function sessionLogRowsFor(logs, runtimeSessionId, v1Rows) {
+    const found = findThread(logs, runtimeSessionId);
+    if (!found)
+        return v1Rows;
+    const { state, head, list } = found;
+    const cached = merged.get(list);
+    const native = nativeOf(head);
+    if (cached && cached.v1Rows === v1Rows && cached.native === native && cached.revs === state.revs)
+        return cached.result;
+    const result = list.flatMap((m) => rowsOf(head, m)).sort(v1Order);
+    const shown = new Set(result.map((r) => r.info.id));
+    for (const row of v1Rows) {
+        if (shown.has(row.info.id) || state.revs[row.info.id] !== undefined)
+            continue;
+        result.splice(insertAt(result, row), 0, row);
+    }
+    merged.set(list, { v1Rows, native, revs: state.revs, result });
+    return result;
+}
+const converted = new WeakMap();
+const views = new WeakMap();
+const isObj = (v) => typeof v === 'object' && v !== null;
+const iso = (ms) => (ms !== undefined && Number.isFinite(ms) && Math.abs(ms) <= 8.64e15 ? new Date(ms).toISOString() : null);
+const isMarker = (row) => row.info.role === 'user' && row.parts.some((p) => isObj(p) && p.type === 'compaction');
+const summaryOf = (row, marker) => {
+    const info = row.info;
+    return info.role === 'assistant' && info.summary === true && info.parentID === marker.info.id;
+};
+function convert(sessionId, native, row, sum, seq) {
+    const cached = converted.get(row);
+    if (cached && cached.sessionId === sessionId && cached.native === native && cached.sum === sum && cached.seq === seq)
+        return cached;
+    const unit = sum ? [row, sum] : [row];
+    const log = fromV1({ session_id: sessionId, root_id: native, rows: unit.map((r) => ({ runtime_session_id: native, info: r.info, parts: r.parts })) }, { live: true });
+    const entry = { sessionId, native, sum, seq, message: { ...log.threads[0].messages[0], seq }, lost: log.grade_counts };
+    converted.set(row, entry);
+    return entry;
+}
+export function sessionLogOfV1Rows(sessionId, runtimeSessionId, rows) {
+    const cached = views.get(rows);
+    if (cached && cached.sessionId === sessionId && cached.native === runtimeSessionId)
+        return cached.log;
+    const sorted = [...rows].sort(v1Order);
+    const paired = new Map();
+    const used = new Set();
+    for (const row of sorted) {
+        if (!isMarker(row))
+            continue;
+        const sum = sorted.find((r) => !used.has(r) && summaryOf(r, row));
+        if (!sum)
+            continue;
+        paired.set(row, sum);
+        used.add(sum);
+    }
+    const counts = { tool_input: 0, cut_point: 0, attachment: 0 };
+    const messages = [];
+    for (const row of sorted) {
+        if (used.has(row))
+            continue;
+        const entry = convert(sessionId, runtimeSessionId, row, paired.get(row), messages.length + 1);
+        for (const k of ['tool_input', 'cut_point', 'attachment'])
+            counts[k] += entry.lost[k];
+        messages.push(entry.message);
+    }
+    const created = iso(sorted.map(createdOf).find((t) => typeof t === 'number' && Number.isFinite(t))) ?? '';
+    const users = messages.filter((m) => m.role === 'user' && m.kind === 'turn');
+    const log = {
+        ...SHELL,
+        session_id: sessionId,
+        created_at: created,
+        restore_grade: counts.tool_input + counts.cut_point + counts.attachment > 0 ? 'partial' : 'converted',
+        grade_counts: counts,
+        harness: { current: 'opencode', history: [] },
+        selection: { agent: users.at(-1)?.agent ?? null, model: users.at(-1)?.model ?? null },
+        threads: [{
+                schema: SESSION_LOG_SCHEMA, v: SESSION_LOG_MINOR, thread_id: runtimeSessionId, parent_thread_id: null, spawned_by: null,
+                agent: users[0]?.agent ?? null, title: null, created_at: messages[0]?.created_at || created, messages,
+                ext: { opencode: { version: BEEUNI_TRANSCRIPT_SCHEMA, native_id: runtimeSessionId } },
+            }],
+    };
+    views.set(rows, { sessionId, native: runtimeSessionId, log });
+    return log;
+}

package/dist/core/session-log/v1.d.ts

@@ -0,0 +1,31 @@
+import type { BeeuniFilePart, BeeuniMessageInfo, BeeuniPart } from '../runtime/transcript-types.js';
+import { type SessionLog } from './types.js';
+export type V1Row = {
+    runtime_session_id: string | null;
+    info: BeeuniMessageInfo;
+    parts: BeeuniPart[];
+};
+export type V1Transcript = {
+    session_id: string;
+    root_id: string | null;
+    rows: V1Row[];
+};
+export type V1Attachment = {
+    ref: string;
+    bytes: number;
+    sha256?: string;
+};
+export type FromV1Options = {
+    harness?: 'opencode' | 'pi';
+    resolveAttachment?: (part: BeeuniFilePart) => V1Attachment | null;
+    live?: boolean;
+};
+export type V1Change = {
+    set: unknown;
+} | {
+    del: true;
+} | {
+    sub: Record<string, V1Change>;
+};
+export declare function toV1(input: SessionLog): V1Transcript;
+export declare function fromV1(v1: V1Transcript, options?: FromV1Options): SessionLog;

package/dist/core/session-log/v1.js

@@ -0,0 +1,466 @@
+import { BEEUNI_TRANSCRIPT_SCHEMA, isTurnErrorCode } from '../runtime/transcript-types.js';
+import { SESSION_LOG_MINOR, SESSION_LOG_SCHEMA, } from './types.js';
+const IMPORT = 'beeuni-v1-import';
+const PRODUCER = { harness: IMPORT, harness_version: BEEUNI_TRANSCRIPT_SCHEMA, adapter_version: '1' };
+const V = { schema: SESSION_LOG_SCHEMA, v: SESSION_LOG_MINOR };
+const INTERRUPTED = { opencode: '[Tool execution was interrupted]', pi: 'No result provided' };
+const CLEARED = '[Old tool result content cleared]';
+const SUBTASK_TEXT = 'The following tool was executed by the user';
+const KIND = new Map(Object.entries({
+    bash: 'shell', powershell: 'shell', read: 'read', write: 'write', edit: 'edit', multiedit: 'edit', patch: 'patch', apply_patch: 'patch',
+    list: 'list', ls: 'list', glob: 'glob', find: 'glob', grep: 'grep', webfetch: 'web_fetch', websearch: 'web_search', codesearch: 'web_search',
+    todowrite: 'todo', todoread: 'todo', task: 'task', question: 'question', plan_enter: 'plan', plan_exit: 'plan',
+}));
+const kindOf = (name) => KIND.get(name) ?? (name.includes('_') ? 'mcp' : 'other');
+const FINISH_V2 = new Map([['stop', 'stop'], ['tool-calls', 'tool_calls'], ['length', 'length'], ['error', 'error']]);
+const FINISH_V1 = new Map([['stop', 'stop'], ['tool_calls', 'tool-calls'], ['length', 'length'], ['error', 'error']]);
+const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const str = (v) => (typeof v === 'string' ? v : undefined);
+const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : undefined);
+const own = (o, k) => (Object.hasOwn(o, k) ? o[k] : undefined);
+const define = (o, k, v) => Object.defineProperty(o, k, { value: v, enumerable: true, writable: true, configurable: true });
+const iso = (ms) => (num(ms) !== undefined && Math.abs(ms) <= 8.64e15 ? new Date(ms).toISOString() : null);
+const msOf = (s) => {
+    const t = s ? Date.parse(s) : NaN;
+    return Number.isNaN(t) ? undefined : t;
+};
+function same(a, b) {
+    if (a === b)
+        return true;
+    if (Array.isArray(a) || Array.isArray(b))
+        return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((x, i) => same(x, b[i]));
+    if (!isObj(a) || !isObj(b))
+        return false;
+    const ka = Object.keys(a).filter((k) => a[k] !== undefined);
+    return ka.length === Object.keys(b).filter((k) => b[k] !== undefined).length && ka.every((k) => same(a[k], own(b, k)));
+}
+function diff(stored, built) {
+    if (same(stored, built))
+        return undefined;
+    if (stored === undefined)
+        return { del: true };
+    if (!isObj(stored) || !isObj(built))
+        return { set: stored };
+    const sub = {};
+    for (const k of new Set([...Object.keys(stored), ...Object.keys(built)])) {
+        const change = diff(own(stored, k), own(built, k));
+        if (change)
+            define(sub, k, change);
+    }
+    return { sub };
+}
+function apply(built, change) {
+    if (!change)
+        return built;
+    if ('set' in change)
+        return change.set;
+    if ('del' in change)
+        return undefined;
+    const out = isObj(built) ? { ...built } : {};
+    for (const [k, c] of Object.entries(change.sub)) {
+        const v = apply(own(out, k), c);
+        if (v === undefined)
+            delete out[k];
+        else
+            define(out, k, v);
+    }
+    return out;
+}
+const v1Ext = (ext) => Object.values(ext ?? {}).find((e) => e.version === BEEUNI_TRANSCRIPT_SCHEMA);
+const extOf = (h, entry) => ({ [h]: { version: BEEUNI_TRANSCRIPT_SCHEMA, ...entry } });
+const urlOf = (a, c) => a.url !== undefined ? { url: a.url } : a.ref !== undefined && !c.fromV1 ? { url: a.ref } : {};
+const textOf = (content) => (content ?? []).flatMap((c) => (c.type === 'text' ? [c.text] : [])).join('');
+const head = (b, c) => ({ id: b.id, ...(c.sessionID !== null && { sessionID: c.sessionID }), messageID: c.messageID });
+function toolState(b, c, base) {
+    const r = b.result;
+    const input = b.input === null || b.input === undefined ? {} : { input: b.input };
+    const start = msOf(b.started_at) ?? c.created;
+    const end = msOf(b.ended_at) ?? start;
+    const meta = r?.exit_code !== undefined ? { exit: r.exit_code } : {};
+    if (b.status === 'pending')
+        return { status: 'pending', input: b.input ?? {}, raw: '' };
+    if (b.status === 'running')
+        return { status: 'running', input: b.input ?? {}, ...(b.title && { title: b.title }), time: { start } };
+    if (b.status === 'error')
+        return { status: 'error', ...input, error: textOf(r?.content), ...(r?.exit_code !== undefined && { metadata: meta }), time: { start, end } };
+    const atts = (r?.content ?? []).flatMap((x, i) => x.type === 'attachment' ? [{ ...base, id: `${b.id}-a${i}`, type: 'file', mime: x.mime, ...urlOf(x, c) }] : []);
+    const compacted = msOf(r?.cleared_at);
+    return {
+        status: 'completed', ...input, output: textOf(r?.content), title: b.title ?? '', metadata: meta,
+        time: { start, end, ...(compacted !== undefined && { compacted }) },
+        ...(atts.length && { attachments: atts }),
+    };
+}
+function partOf(b, c) {
+    const base = head(b, c);
+    switch (b.type) {
+        case 'text': return { ...base, type: 'text', text: b.text, ...(b.synthetic !== undefined && { synthetic: b.synthetic }) };
+        case 'reasoning': return { ...base, type: 'reasoning', text: b.text, time: { start: c.created } };
+        case 'attachment': return { ...base, type: 'file', mime: b.mime, ...(b.name !== undefined && { filename: b.name }), ...urlOf(b, c) };
+        case 'tool_call': return { ...base, type: 'tool', callID: b.call_id, tool: b.name, state: toolState(b, c, { ...(c.sessionID !== null && { sessionID: c.sessionID }), messageID: c.messageID }) };
+        case 'step': return b.phase === 'start'
+            ? { ...base, type: 'step-start' }
+            : { ...base, type: 'step-finish', reason: 'stop', cost: 0, tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } } };
+        case 'compaction': return {
+            ...base, type: 'compaction', auto: b.trigger === 'auto' || b.trigger === 'overflow',
+            ...(b.trigger === 'overflow' && { overflow: true }), ...(b.first_kept_message_id !== null && { tail_start_id: b.first_kept_message_id }),
+        };
+        case 'harness':
+            if (c.fromV1 && (b.harness === 'opencode' || b.harness === 'pi'))
+                return b.data;
+            return b.model_visible && b.fallback_text !== undefined ? { ...base, type: 'text', text: b.fallback_text, synthetic: true } : undefined;
+        case 'subtask': return undefined;
+    }
+}
+function errorV1(e) {
+    if (!isTurnErrorCode(e.code))
+        return { name: e.code, data: { message: e.message } };
+    return { name: e.code === 'aborted' ? 'MessageAbortedError' : 'UnknownError', code: e.code, data: { message: e.message } };
+}
+function assistantInfo(m, c, over = {}) {
+    const u = m.usage;
+    const finish = m.finish === null ? undefined : FINISH_V1.get(m.finish);
+    return {
+        id: m.message_id, ...(c.sessionID !== null && { sessionID: c.sessionID }), role: 'assistant',
+        time: { created: c.created, ...(m.completed_at !== null && { completed: msOf(m.completed_at) }) },
+        ...(m.reply_to && { parentID: m.reply_to }),
+        modelID: m.model?.model ?? '', providerID: m.model?.provider ?? '', ...(m.model?.variant !== undefined && { variant: m.model.variant }),
+        mode: m.agent ?? '', agent: m.agent ?? '', path: { cwd: '', root: '' },
+        cost: u?.cost ?? 0, tokens: { input: u?.input ?? 0, output: u?.output ?? 0, reasoning: u?.reasoning ?? 0, cache: { read: u?.cache_read ?? 0, write: u?.cache_write ?? 0 } },
+        ...(finish && { finish }), ...(m.error && { error: errorV1(m.error) }),
+        ...over,
+    };
+}
+function infoOf(m, c) {
+    if (m.role === 'assistant')
+        return assistantInfo(m, c);
+    return {
+        id: m.message_id, ...(c.sessionID !== null && { sessionID: c.sessionID }), role: 'user', time: { created: c.created },
+        agent: m.agent ?? '', model: { providerID: m.model?.provider ?? '', modelID: m.model?.model ?? '', ...(m.model?.variant !== undefined && { variant: m.model.variant }) },
+    };
+}
+function summaryOf(m, cb, c) {
+    const id = `${m.message_id}-summary`;
+    const info = assistantInfo({ ...m, reply_to: m.message_id, agent: 'compaction', finish: m.status === 'complete' ? 'stop' : null }, c, { id, summary: true });
+    return { info, parts: [{ id: `${id}-p0`, ...(c.sessionID !== null && { sessionID: c.sessionID }), messageID: id, type: 'text', text: cb.summary }] };
+}
+function rowsOf(m, threadNative, v1Thread) {
+    const v1 = v1Thread || m.producer.harness === IMPORT;
+    if (!v1 && (m.role === 'system' || m.kind === 'context'))
+        return [];
+    const d = v1Ext(m.ext)?.data;
+    const sessionID = d && 'runtime_session_id' in d ? d.runtime_session_id ?? null : threadNative;
+    const c = { sessionID, messageID: m.message_id, created: msOf(m.created_at), fromV1: v1 };
+    const parts = d && 'parts' in d
+        ? d.parts
+        : m.blocks.flatMap((b) => {
+            const p = partOf(b, c);
+            return p === undefined ? [] : [apply(p, v1Ext(b.ext)?.data)];
+        });
+    const rows = [{ runtime_session_id: sessionID, info: apply(infoOf(m, c), d?.info), parts }];
+    const cb = m.blocks.find((b) => b.type === 'compaction');
+    if (m.kind === 'compaction' && cb && cb.summary !== null) {
+        const s = apply(summaryOf(m, cb, c), d?.summary);
+        rows.push({ runtime_session_id: sessionID, info: s.info, parts: s.parts });
+    }
+    return rows;
+}
+const created = (r) => num(isObj(r.info) && isObj(r.info.time) ? r.info.time.created : undefined) ?? -Infinity;
+const idOf = (r) => String(isObj(r.info) ? r.info.id : '');
+const rowOrder = (a, b) => created(a) - created(b) || (idOf(a) < idOf(b) ? -1 : idOf(a) > idOf(b) ? 1 : 0);
+const threadNativeOf = (t) => {
+    const e = v1Ext(t.ext);
+    return e ? e.native_id ?? null : t.thread_id;
+};
+export function toV1(input) {
+    const log = structuredClone(input);
+    const root = log.threads.find((t) => t.parent_thread_id === null) ?? log.threads[0];
+    const rows = log.threads.flatMap((t) => t.messages.flatMap((m) => rowsOf(m, threadNativeOf(t), v1Ext(t.ext) !== undefined)));
+    const stated = v1Ext(log.ext)?.data;
+    const rootId = stated && 'root_id' in stated ? stated.root_id ?? null : root ? threadNativeOf(root) : null;
+    return { session_id: log.session_id, root_id: rootId, rows: rows.sort(rowOrder) };
+}
+function modelOf(info) {
+    const src = info.role === 'assistant' ? { p: info.providerID, m: info.modelID, v: info.variant } : isObj(info.model) ? { p: info.model.providerID, m: info.model.modelID, v: info.model.variant } : {};
+    const provider = str(src.p);
+    const model = str(src.m);
+    return provider === undefined || model === undefined ? null : { provider, model, ...(str(src.v) !== undefined && { variant: src.v }) };
+}
+function usageOf(info) {
+    if (!isObj(info.tokens))
+        return null;
+    const t = info.tokens;
+    const cache = isObj(t.cache) ? t.cache : {};
+    return {
+        input: num(t.input) ?? 0, output: num(t.output) ?? 0, cache_read: num(cache.read) ?? 0, cache_write: num(cache.write) ?? 0,
+        ...(num(t.reasoning) !== undefined && { reasoning: t.reasoning }), ...(num(info.cost) !== undefined && { cost: info.cost }),
+    };
+}
+const errorOf = (e) => ({ code: str(e.code) || str(e.name) || 'UnknownError', message: str(isObj(e.data) ? e.data.message : undefined) ?? '' });
+function attachment(p, c, lost) {
+    const r = c.resolve(p);
+    if (!r)
+        lost.attachment++;
+    return {
+        mime: str(p.mime) ?? 'application/octet-stream',
+        ...(r && { ref: r.ref, bytes: r.bytes, ...(r.sha256 !== undefined && { sha256: r.sha256 }) }),
+        ...(str(p.url) !== undefined && { url: p.url }),
+    };
+}
+function toolBlock(p, id, c, lost) {
+    const st = p.state;
+    const time = isObj(st.time) ? st.time : {};
+    if (!isObj(st.input))
+        lost.tool_input++;
+    const exit = isObj(st.metadata) && num(st.metadata.exit) !== undefined ? { exit_code: st.metadata.exit } : {};
+    let status;
+    let result;
+    let input = st.input ?? null;
+    if (st.status === 'completed') {
+        const atts = (Array.isArray(st.attachments) ? st.attachments : []).filter(isObj).map((a) => {
+            const { bytes: _bytes, ...content } = attachment(a, c, lost);
+            return { type: 'attachment', ...content };
+        });
+        const cleared = iso(time.compacted);
+        status = 'complete';
+        result = {
+            content: [...(str(st.output) !== undefined ? [{ type: 'text', text: st.output }] : []), ...atts], is_error: false, ...exit,
+            ...(cleared && { model_content: [{ type: 'text', text: CLEARED }], cleared_at: cleared }),
+        };
+    }
+    else if (st.status === 'error') {
+        const error = str(st.error);
+        status = 'error';
+        result = { content: error !== undefined ? [{ type: 'text', text: error }] : [], is_error: true, ...(error !== undefined && { error: { message: error } }), ...exit };
+    }
+    else if (c.live) {
+        status = st.status === 'pending' ? 'pending' : 'running';
+        if (status === 'pending' && str(st.raw) && !(isObj(st.input) && Object.keys(st.input).length))
+            input = st.raw;
+    }
+    else {
+        const text = INTERRUPTED[c.h];
+        status = 'error';
+        result = { content: [{ type: 'text', text }], is_error: true, synthetic: true, error: { code: 'interrupted', message: text } };
+    }
+    const started = iso(time.start);
+    const ended = iso(time.end);
+    return {
+        type: 'tool_call', id, call_id: p.callID, name: p.tool, kind: kindOf(p.tool), input, status, ...(result && { result }),
+        ...(str(st.title) && { title: st.title }), ...(started && { started_at: started }), ...(ended && { ended_at: ended }),
+    };
+}
+function blockOf(p, id, marker, summary, c, lost) {
+    const harness = (kind, model_visible = false) => ({
+        type: 'harness', id, harness: c.h, kind, data: p, model_visible, ...(model_visible && { fallback_text: SUBTASK_TEXT }),
+    });
+    if (!isObj(p))
+        return harness('unknown');
+    switch (p.type) {
+        case 'text':
+            return typeof p.text !== 'string' || p.ignored === true ? harness('text') : { type: 'text', id, text: p.text, ...(typeof p.synthetic === 'boolean' && { synthetic: p.synthetic }) };
+        case 'reasoning':
+            return typeof p.text !== 'string' ? harness('reasoning') : { type: 'reasoning', id, text: p.text };
+        case 'file': {
+            if (p.mime === 'text/plain' || p.mime === 'application/x-directory')
+                return harness('file');
+            return { type: 'attachment', id, ...attachment(p, c, lost), ...(str(p.filename) !== undefined && { name: p.filename }) };
+        }
+        case 'tool':
+            return typeof p.callID === 'string' && typeof p.tool === 'string' && isObj(p.state) ? toolBlock(p, id, c, lost) : harness('tool');
+        case 'step-start':
+        case 'step-finish':
+            return { type: 'step', id, phase: p.type === 'step-start' ? 'start' : 'finish' };
+        case 'compaction': {
+            if (p !== marker)
+                return harness('compaction');
+            const trigger = p.overflow === true ? 'overflow' : p.auto === true ? 'auto' : 'manual';
+            return { type: 'compaction', id, summary, first_kept_message_id: str(p.tail_start_id) ?? null, trigger };
+        }
+        case 'subtask':
+            return harness('subtask', true);
+        default:
+            return harness(str(p.type) || 'unknown');
+    }
+}
+function blockIds(parts) {
+    const given = parts.map((p, i) => (isObj(p) && typeof p.id === 'string' && p.id ? p.id : `#${i}`));
+    const taken = new Set(given);
+    const seen = new Set();
+    return given.map((id) => {
+        if (!seen.has(id)) {
+            seen.add(id);
+            return id;
+        }
+        let n = 2;
+        while (taken.has(`${id}#${n}`))
+            n++;
+        taken.add(`${id}#${n}`);
+        return `${id}#${n}`;
+    });
+}
+function toMessage(row, sum, threadId, seq, superseded, c) {
+    const info = isObj(row.info) ? row.info : {};
+    const parts = Array.isArray(row.parts) ? row.parts : [];
+    const marker = info.role === 'user' ? parts.find((p) => isObj(p) && p.type === 'compaction') : undefined;
+    const sInfo = sum && isObj(sum.info) ? sum.info : undefined;
+    const role = info.role === 'assistant' || info.role === 'user' ? info.role : 'system';
+    const src = marker ? sInfo : role === 'assistant' ? info : undefined;
+    const err = src && isObj(src.error) ? src.error : undefined;
+    const aborted = err?.name === 'MessageAbortedError';
+    const completedAt = src && isObj(src.time) ? iso(src.time.completed) : null;
+    const open = c.live ? 'streaming' : 'interrupted';
+    const status = !src ? (marker ? open : 'complete') : err ? (aborted ? 'aborted' : 'error') : completedAt ? 'complete' : open;
+    const createdAt = iso(isObj(info.time) ? info.time.created : undefined) ?? '';
+    const summary = sum ? (Array.isArray(sum.parts) ? sum.parts : []).flatMap((p) => (isObj(p) && p.type === 'text' && typeof p.text === 'string' ? [p.text] : [])).join('') : null;
+    const lost = { tool_input: 0, cut_point: 0, attachment: 0 };
+    const ids = blockIds(parts);
+    const blocks = parts.map((p, i) => blockOf(p, ids[i], marker, summary, c, lost));
+    const visible = blocks.some((b) => b.type === 'text' || b.type === 'attachment' || b.type === 'tool_call' || (b.type === 'harness' && b.model_visible));
+    const inContext = !superseded && role !== 'system' && (marker ? status === 'complete' : !err || (aborted && visible));
+    const hidden = superseded ? 'superseded' : inContext || !err ? undefined : aborted ? 'aborted' : 'failed_attempt';
+    if (marker && isObj(marker) && str(marker.tail_start_id) === undefined)
+        lost.cut_point++;
+    const m = {
+        ...V, message_id: str(info.id) ?? '', thread_id: threadId, seq, role, kind: marker ? 'compaction' : 'turn', status, in_context: inContext,
+        ...(hidden && { hidden_reason: hidden }),
+        agent: str(info.agent) ?? null,
+        ...(role === 'assistant' && { reply_to: str(info.parentID) ?? null }),
+        model: modelOf(info), usage: src ? usageOf(src) : null,
+        finish: !src || marker ? null : aborted ? 'aborted' : err ? 'error' : FINISH_V2.get(info.finish) ?? null,
+        error: err ? errorOf(err) : null,
+        created_at: createdAt, completed_at: src || marker ? completedAt : createdAt || null,
+        producer: PRODUCER, blocks,
+    };
+    return { m, lost };
+}
+function keepResidual(m, row, sum, threadNative, h) {
+    const data = {};
+    if (row.runtime_session_id !== threadNative)
+        data.runtime_session_id = row.runtime_session_id;
+    const c = { sessionID: row.runtime_session_id, messageID: m.message_id, created: msOf(m.created_at), fromV1: true };
+    if (Array.isArray(row.parts)) {
+        m.blocks.forEach((b, i) => {
+            if (b.type === 'harness' || b.type === 'subtask')
+                return;
+            const change = diff(row.parts[i], partOf(b, c));
+            if (change)
+                b.ext = extOf(h, { data: change });
+        });
+    }
+    else
+        data.parts = row.parts;
+    const info = diff(row.info, infoOf(m, c));
+    if (info)
+        data.info = info;
+    const cb = m.blocks.find((b) => b.type === 'compaction');
+    if (sum && cb) {
+        const change = diff({ info: sum.info, parts: sum.parts }, summaryOf(m, cb, c));
+        if (change)
+            data.summary = change;
+    }
+    if (Object.keys(data).length)
+        m.ext = extOf(h, { data });
+}
+function spawnerOf(rows, id, text) {
+    if (!id)
+        return undefined;
+    for (const exact of [true, false]) {
+        for (const row of rows) {
+            if (row.runtime_session_id === id || !Array.isArray(row.parts))
+                continue;
+            for (const p of row.parts) {
+                if (!isObj(p) || p.type !== 'tool' || !isObj(p.state))
+                    continue;
+                if (exact ? isObj(p.state.metadata) && p.state.metadata.sessionId === id : text(p.state).includes(id))
+                    return { row, part: p };
+            }
+        }
+    }
+    return undefined;
+}
+export function fromV1(v1, options = {}) {
+    const c = { h: options.harness ?? 'opencode', resolve: options.resolveAttachment ?? (() => null), counts: { tool_input: 0, cut_point: 0, attachment: 0 }, live: options.live === true };
+    const rows = structuredClone(v1.rows).sort(rowOrder);
+    const groups = new Map();
+    for (const r of rows) {
+        const list = groups.get(r.runtime_session_id);
+        if (list)
+            list.push(r);
+        else
+            groups.set(r.runtime_session_id, [r]);
+    }
+    const stated = v1.root_id;
+    const usable = groups.has(stated);
+    const texts = new Map();
+    const text = (state) => texts.get(state) ?? (texts.set(state, JSON.stringify(state)), texts.get(state));
+    const spawners = new Map();
+    for (const id of groups.keys()) {
+        const s = usable && id === stated ? undefined : spawnerOf(rows, id, text);
+        if (s)
+            spawners.set(id, s);
+    }
+    const latest = [...rows].reverse().find((r) => r.runtime_session_id === null || !spawners.has(r.runtime_session_id));
+    const root = usable || !latest ? stated : latest.runtime_session_id;
+    if (!groups.has(root))
+        groups.set(root, []);
+    const rootThread = root || v1.session_id;
+    const threadOf = (id) => (id !== null && spawners.has(id) ? id : rootThread);
+    const sessionCreated = iso(rows.map(created).find(Number.isFinite)) ?? '';
+    const threads = [];
+    for (const [id, own] of groups) {
+        if (id !== root && (id === null || !spawners.has(id)))
+            continue;
+        const isRoot = id === root;
+        const superseded = isRoot ? rows.filter((r) => r.runtime_session_id !== root && threadOf(r.runtime_session_id) === rootThread) : [];
+        const list = [...superseded, ...own];
+        const old = new Set(superseded);
+        const summaries = new Map();
+        const paired = new Set();
+        for (const row of list) {
+            const info = isObj(row.info) ? row.info : {};
+            if (info.role !== 'user' || !Array.isArray(row.parts) || !row.parts.some((p) => isObj(p) && p.type === 'compaction'))
+                continue;
+            const sum = list.find((r) => !paired.has(r) && r.runtime_session_id === row.runtime_session_id && isObj(r.info) && r.info.role === 'assistant' && r.info.summary === true && r.info.parentID === info.id);
+            if (!sum)
+                continue;
+            summaries.set(row, sum);
+            paired.add(sum);
+        }
+        const messages = [];
+        for (const row of list) {
+            if (paired.has(row))
+                continue;
+            const sum = summaries.get(row);
+            const { m, lost } = toMessage(row, sum, isRoot ? rootThread : id, messages.length + 1, old.has(row), c);
+            keepResidual(m, row, sum, id, c.h);
+            if (m.in_context)
+                for (const k of ['tool_input', 'cut_point', 'attachment'])
+                    c.counts[k] += lost[k];
+            messages.push(m);
+        }
+        const spawn = id === null ? undefined : spawners.get(id);
+        const firstUser = messages.find((m) => m.role === 'user' && m.kind === 'turn');
+        threads.push({
+            ...V, thread_id: isRoot ? rootThread : id,
+            parent_thread_id: spawn ? threadOf(spawn.row.runtime_session_id) : null,
+            spawned_by: spawn && typeof spawn.part.callID === 'string' ? { message_id: str(spawn.row.info?.id) ?? '', call_id: spawn.part.callID } : null,
+            agent: firstUser?.agent ?? null, title: null, created_at: messages[0]?.created_at || sessionCreated, messages,
+            ext: extOf(c.h, id === null ? {} : { native_id: id }),
+        });
+    }
+    threads.sort((a, b) => (a.parent_thread_id === null ? -1 : b.parent_thread_id === null ? 1 : rowsIndex(a) - rowsIndex(b)));
+    const lastUser = threads[0]?.messages.filter((m) => m.role === 'user' && m.kind === 'turn').at(-1);
+    const partial = c.counts.tool_input + c.counts.cut_point + c.counts.attachment > 0;
+    return {
+        ...V, session_id: v1.session_id, title: null, created_at: sessionCreated,
+        restore_grade: partial ? 'partial' : 'converted', grade_counts: c.counts,
+        harness: { current: c.h, history: [] },
+        selection: { agent: lastUser?.agent ?? null, model: lastUser?.model ?? null },
+        todos: [], pending: { questions: [], permissions: [] }, threads,
+        ...(root !== stated && { ext: extOf(c.h, { data: { root_id: stated } }) }),
+    };
+    function rowsIndex(t) {
+        return rows.findIndex((r) => r.runtime_session_id === t.thread_id);
+    }
+}

package/dist/core/session-sync/copy-store-types.d.ts

@@ -0,0 +1,19 @@
+import type { SessionTranscriptSyncEnvelope } from '../rest/projects-client/sessions.js';
+export interface StoredCopy<T = SessionTranscriptSyncEnvelope> {
+    v: number;
+    user: string;
+    at: number;
+    e: T;
+}
+export interface CopyCodec<T> {
+    paintable(value: T | null | undefined): value is T;
+    fit(stored: StoredCopy<T>, maxChars: number): string | null;
+    capturedAt(value: T): number;
+}
+export interface CopyStore<T> {
+    keyFor(projectId: string, sessionId: string): string;
+    read(projectId: string, sessionId: string): T | null | Promise<T | null>;
+    write(projectId: string, sessionId: string, value: T): Promise<void>;
+    remove(projectId: string, sessionId: string): Promise<void>;
+    clear(): Promise<void>;
+}

package/dist/core/session-sync/copy-store-types.js

@@ -0,0 +1 @@
+export {};