specrails-desktop 2.0.0

package/server/dist/file-provenance.js

@@ -0,0 +1,382 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveHeadSha = resolveHeadSha;
+exports.listUntracked = listUntracked;
+exports.snapshotWorkingTree = snapshotWorkingTree;
+exports.diffAgainstSnapshot = diffAgainstSnapshot;
+exports.collectDiffPatches = collectDiffPatches;
+exports.recordProvenanceForJob = recordProvenanceForJob;
+exports.getProvenanceDiff = getProvenanceDiff;
+exports.listProvenanceByTicket = listProvenanceByTicket;
+exports.listProvenanceByPath = listProvenanceByPath;
+exports.broadcastProvenanceUpdated = broadcastProvenanceUpdated;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const MAX_PATCH_BYTES = 512 * 1024;
+// These git calls run synchronously on the main event loop (pre-spawn snapshot
+// and post-exit diff). Bound every one: a timeout so a stuck index.lock /
+// filesystem stall / credential prompt can't freeze the whole app, a maxBuffer
+// cap, and an env that disables any interactive prompt. The existing try/catch
+// in each function degrades a timeout to empty provenance. Mirrors metrics.ts.
+const GIT_TIMEOUT_MS = 15_000;
+const GIT_MAX_BUFFER = 16 * 1024 * 1024;
+// Bound on how many per-file patches we collect after a job. Each is a synchronous
+// git spawn on the event loop, so a job touching hundreds of files would otherwise
+// block the whole app. Provenance ROWS are recorded for every path regardless; only
+// the on-demand diff patches beyond this cap are skipped (the UI shows "diff
+// unavailable" for them). Mirrors the existing large-job warn threshold (50).
+const MAX_PATCH_FILES = 50;
+const GIT_EXEC_ENV = (() => {
+    // Inherit the parent env but STRIP git-location vars. If the app process (or a
+    // parent) ever exports GIT_DIR / GIT_WORK_TREE / GIT_INDEX_FILE, every cwd-scoped
+    // git call below would silently operate on that repo instead of the project —
+    // corrupting provenance. Always pin git to the cwd we pass.
+    const env = { ...process.env };
+    delete env.GIT_DIR;
+    delete env.GIT_WORK_TREE;
+    delete env.GIT_INDEX_FILE;
+    delete env.GIT_COMMON_DIR;
+    delete env.GIT_OBJECT_DIRECTORY;
+    env.GIT_TERMINAL_PROMPT = '0';
+    env.GIT_ASKPASS = 'echo';
+    env.GCM_INTERACTIVE = 'never';
+    // M2: these git calls run INSIDE the project repo (cwd = project.path) for every
+    // queued job, and git honors the repo's own .git/config. A hostile repo added as
+    // a project can ship `[core] fsmonitor = <script>` (or a hook) that git executes
+    // during index refresh (stash create / diff / status) → RCE on job spawn. Strip
+    // system config and override the hook-bearing keys for ALL invocations via
+    // GIT_CONFIG_PARAMETERS (same precedence as `-c`, so it wins over the repo's
+    // local config). Disabling fsmonitor only costs a perf hint; provenance reads
+    // never need hooks.
+    env.GIT_CONFIG_NOSYSTEM = '1';
+    env.GIT_CONFIG_PARAMETERS = "'core.fsmonitor=false' 'core.hooksPath=/dev/null' 'protocol.ext.allow=user'";
+    return env;
+})();
+/** Resolve the current HEAD commit SHA. Best-effort: '' on any git failure
+ *  (no repo, unborn HEAD, no git, timeout). */
+function resolveHeadSha(cwd) {
+    try {
+        const out = (0, child_process_1.execSync)('git rev-parse HEAD', {
+            cwd,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+            timeout: GIT_TIMEOUT_MS,
+            maxBuffer: GIT_MAX_BUFFER,
+            env: GIT_EXEC_ENV,
+        });
+        return out.trim();
+    }
+    catch {
+        return '';
+    }
+}
+/** List untracked, non-ignored paths in the working tree. Best-effort: any git
+ *  failure (no git, no repo, timeout) degrades to []. */
+function listUntracked(cwd) {
+    try {
+        const out = (0, child_process_1.execSync)('git ls-files --others --exclude-standard -z', {
+            cwd,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+            timeout: GIT_TIMEOUT_MS,
+            maxBuffer: GIT_MAX_BUFFER,
+            env: GIT_EXEC_ENV,
+        });
+        return out.split('\0').filter((p) => p.length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+function snapshotWorkingTree(cwd) {
+    let ref = '';
+    try {
+        const out = (0, child_process_1.execSync)('git stash create --include-untracked', {
+            cwd,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+            timeout: GIT_TIMEOUT_MS,
+            maxBuffer: GIT_MAX_BUFFER,
+            env: GIT_EXEC_ENV,
+        });
+        ref = out.trim();
+    }
+    catch (err) {
+        const msg = err.message ?? '';
+        if (/ENOENT|not found|command not found/i.test(msg)) {
+            throw err;
+        }
+        ref = '';
+    }
+    // Capture the untracked set NOW so the post-job diff can tell rail-created
+    // files apart from files that were already untracked before the job ran. Also
+    // freeze the HEAD SHA so a job that commits from a clean tree is still diffed
+    // against its true starting point (not the post-commit HEAD).
+    return { ref, untracked: listUntracked(cwd), headSha: resolveHeadSha(cwd) };
+}
+function diffAgainstSnapshot(cwd, snapshotRef, untrackedBefore, baseSha) {
+    const hasSnap = snapshotRef && snapshotRef.length > 0;
+    // When there is no stash ref (clean tree at snapshot time), prefer the frozen
+    // pre-job HEAD SHA over the literal 'HEAD'. A job that commits its output
+    // advances HEAD, so `git diff HEAD` at exit would report nothing — the frozen
+    // base recovers the real created/modified/deleted set.
+    const ref = hasSnap ? snapshotRef : (baseSha && baseSha.length > 0 ? baseSha : 'HEAD');
+    let out = '';
+    try {
+        // --find-renames so rename detection is deterministic regardless of the
+        // user's global `diff.renames` config (matches collectDiffPatches).
+        out = (0, child_process_1.execSync)(`git diff --name-status --find-renames -z ${ref} --`, {
+            cwd,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+            timeout: GIT_TIMEOUT_MS,
+            maxBuffer: GIT_MAX_BUFFER,
+            env: GIT_EXEC_ENV,
+        });
+    }
+    catch {
+        out = '';
+    }
+    const entries = [];
+    const seen = new Set();
+    if (out) {
+        const tokens = out.split('\0').filter((t) => t.length > 0);
+        let i = 0;
+        while (i < tokens.length) {
+            const raw = tokens[i];
+            const code = raw[0];
+            if (code === 'R' || code === 'C') {
+                // Rename/copy: `<status>\0<old>\0<new>\0`.
+                const oldPath = tokens[i + 1];
+                const newPath = tokens[i + 2];
+                if (oldPath !== undefined && newPath !== undefined && !seen.has(newPath)) {
+                    entries.push(code === 'R'
+                        ? { path: newPath, status: 'R', renamedFrom: oldPath }
+                        : { path: newPath, status: 'A' });
+                    seen.add(newPath);
+                }
+                i += 3;
+                continue;
+            }
+            if (code === 'A' || code === 'M' || code === 'D') {
+                const p = tokens[i + 1];
+                if (p !== undefined && !seen.has(p)) {
+                    entries.push({ path: p, status: code });
+                    seen.add(p);
+                }
+                i += 2;
+                continue;
+            }
+            if (code === 'T') {
+                // Typechange (file⇄symlink, regular⇄submodule). Record as modified.
+                const p = tokens[i + 1];
+                if (p !== undefined && !seen.has(p)) {
+                    entries.push({ path: p, status: 'M' });
+                    seen.add(p);
+                }
+                i += 2;
+                continue;
+            }
+            // Unknown single-letter status: `<status>\0<path>\0`. Consume the pair so
+            // the path token is never re-read as a status (which would corrupt the
+            // rest of the stream).
+            i += 2;
+        }
+    }
+    // `git diff <ref>` only reports TRACKED-file deltas — it never lists untracked
+    // files. New files a rail creates are untracked, so without this pass they are
+    // silently lost whenever the tree was dirty at snapshot time (the common case).
+    // Always surface currently-untracked paths, minus those already untracked at
+    // snapshot time (which the rail did not create), as 'A' (created).
+    const before = new Set(untrackedBefore ?? []);
+    for (const p of listUntracked(cwd)) {
+        if (!seen.has(p) && !before.has(p)) {
+            entries.push({ path: p, status: 'A' });
+            seen.add(p);
+        }
+    }
+    return entries;
+}
+function truncatePatch(patch) {
+    const bytes = Buffer.byteLength(patch, 'utf8');
+    if (bytes <= MAX_PATCH_BYTES)
+        return { patch, truncated: false };
+    return {
+        patch: `${patch.slice(0, MAX_PATCH_BYTES)}\n[specrails-desktop] diff truncated at ${MAX_PATCH_BYTES} bytes\n`,
+        truncated: true,
+    };
+}
+function addedFilePatch(cwd, relPath) {
+    const abs = path_1.default.resolve(cwd, relPath);
+    const root = cwd.endsWith(path_1.default.sep) ? cwd : `${cwd}${path_1.default.sep}`;
+    if (abs !== cwd && !abs.startsWith(root))
+        return '';
+    let content = '';
+    try {
+        const stat = fs_1.default.statSync(abs);
+        if (!stat.isFile() || stat.size > MAX_PATCH_BYTES)
+            return '';
+        content = fs_1.default.readFileSync(abs, 'utf8');
+    }
+    catch {
+        return '';
+    }
+    const noTrailingNewline = content.length > 0 && !content.endsWith('\n');
+    const lines = content.split('\n');
+    if (lines.length > 0 && lines[lines.length - 1] === '')
+        lines.pop();
+    const body = lines.map((line) => `+${line}`);
+    // Mirror git's own unified-diff output for a file with no terminating newline.
+    if (noTrailingNewline)
+        body.push('\');
+    return [
+        `diff --git a/${relPath} b/${relPath}`,
+        'new file mode 100644',
+        'index 0000000..0000000',
+        '--- /dev/null',
+        `+++ b/${relPath}`,
+        `@@ -0,0 +1,${lines.length} @@`,
+        ...body,
+        '',
+    ].join('\n');
+}
+function collectDiffPatches(cwd, snapshotRef, diff, baseSha) {
+    const patches = new Map();
+    if (diff.length === 0)
+        return patches;
+    // Same frozen-base fallback as diffAgainstSnapshot: a clean-tree snapshot has
+    // no stash ref, so use the pre-job HEAD SHA to capture patches for committed
+    // work instead of diffing against the (advanced) live HEAD.
+    const ref = snapshotRef && snapshotRef.length > 0
+        ? snapshotRef
+        : (baseSha && baseSha.length > 0 ? baseSha : 'HEAD');
+    // Cap the number of per-file git spawns: each runs synchronously on the event
+    // loop. Beyond the cap, provenance rows are still recorded (by the caller) but
+    // patches are skipped — the UI renders "diff unavailable" for them.
+    const capped = diff.slice(0, MAX_PATCH_FILES);
+    for (const entry of capped) {
+        // For a rename, scope the diff to BOTH paths so git can pair them and emit a
+        // proper `rename from`/`rename to` patch instead of a delete + 100%-add.
+        const pathspec = entry.status === 'R' && entry.renamedFrom !== undefined
+            ? [entry.renamedFrom, entry.path]
+            : [entry.path];
+        let patch = '';
+        try {
+            patch = (0, child_process_1.execFileSync)('git', ['diff', '--no-ext-diff', '--find-renames', '--unified=80', ref, '--', ...pathspec], {
+                cwd,
+                encoding: 'utf8',
+                stdio: ['ignore', 'pipe', 'pipe'],
+                maxBuffer: MAX_PATCH_BYTES + 64 * 1024,
+                timeout: GIT_TIMEOUT_MS,
+                env: GIT_EXEC_ENV,
+            });
+        }
+        catch (err) {
+            patch = (err.stdout ?? '').toString();
+        }
+        if (!patch && entry.status === 'A')
+            patch = addedFilePatch(cwd, entry.path);
+        if (patch)
+            patches.set(entry.path, truncatePatch(patch));
+    }
+    return patches;
+}
+function recordProvenanceForJob(db, projectId, jobId, ticketId, diff, atMs = Date.now(), patches) {
+    void projectId;
+    if (diff.length === 0)
+        return [];
+    const pending = [];
+    for (const entry of diff) {
+        if (entry.status === 'A') {
+            pending.push({ file_path: entry.path, kind: 'created' });
+        }
+        else if (entry.status === 'M') {
+            pending.push({ file_path: entry.path, kind: 'modified' });
+        }
+        else if (entry.status === 'D') {
+            pending.push({ file_path: entry.path, kind: 'deleted' });
+        }
+        else if (entry.status === 'R') {
+            // rename = two rows because tree row tracking needs both the new path (modified) and old path (deleted)
+            pending.push({ file_path: entry.path, kind: 'modified' });
+            if (entry.renamedFrom !== undefined) {
+                pending.push({ file_path: entry.renamedFrom, kind: 'deleted' });
+            }
+        }
+    }
+    const insert = db.prepare(`
+    INSERT INTO file_provenance (file_path, ticket_id, job_id, kind, at)
+    VALUES (?, ?, ?, ?, ?)
+  `);
+    let insertPatch = null;
+    try {
+        insertPatch = db.prepare(`
+      INSERT OR REPLACE INTO file_provenance_diffs (provenance_id, patch, truncated)
+      VALUES (?, ?, ?)
+    `);
+    }
+    catch {
+        insertPatch = null;
+    }
+    const inserted = [];
+    const tx = db.transaction((rows) => {
+        for (const r of rows) {
+            const result = insert.run(r.file_path, ticketId, jobId, r.kind, atMs);
+            inserted.push({
+                id: Number(result.lastInsertRowid),
+                file_path: r.file_path,
+                ticket_id: ticketId,
+                job_id: jobId,
+                kind: r.kind,
+                at: atMs,
+            });
+            const storedPatch = patches?.get(r.file_path);
+            if (insertPatch && storedPatch) {
+                insertPatch.run(Number(result.lastInsertRowid), storedPatch.patch, storedPatch.truncated ? 1 : 0);
+            }
+        }
+    });
+    tx(pending);
+    return inserted;
+}
+function getProvenanceDiff(db, projectId, jobId, filePath) {
+    void projectId;
+    try {
+        const row = db.prepare(`SELECT d.patch, d.truncated
+       FROM file_provenance p
+       JOIN file_provenance_diffs d ON d.provenance_id = p.id
+       WHERE p.job_id = ? AND p.file_path = ?
+       ORDER BY p.at DESC, p.id DESC
+       LIMIT 1`).get(jobId, filePath);
+        return row ? { patch: row.patch, truncated: row.truncated === 1 } : null;
+    }
+    catch {
+        return null;
+    }
+}
+function listProvenanceByTicket(db, projectId, ticketId) {
+    void projectId;
+    return db.prepare(`SELECT id, file_path, ticket_id, job_id, kind, at
+     FROM file_provenance WHERE ticket_id = ? ORDER BY at DESC`).all(ticketId);
+}
+function listProvenanceByPath(db, projectId, filePath) {
+    void projectId;
+    return db.prepare(`SELECT id, file_path, ticket_id, job_id, kind, at
+     FROM file_provenance WHERE file_path = ? ORDER BY at DESC`).all(filePath);
+}
+function broadcastProvenanceUpdated(broadcast, projectId, row) {
+    const msg = {
+        type: 'file.provenance_updated',
+        projectId,
+        path: row.file_path,
+        kind: row.kind,
+        ticketId: row.ticket_id,
+        jobId: row.job_id,
+        at: row.at,
+    };
+    broadcast(msg);
+}

package/server/dist/file-summary-generator.js

@@ -0,0 +1,221 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSystemPrompt = buildSystemPrompt;
+exports.createFileSummaryGenerator = createFileSummaryGenerator;
+const readline_1 = require("readline");
+const tree_kill_1 = __importDefault(require("tree-kill"));
+const cli_prompt_1 = require("./util/cli-prompt");
+const result_event_1 = require("./result-event");
+const GENERATE_TIMEOUT_MS = 60_000;
+const SYSTEM_PROMPT_EN = 'You are explaining code to a non-developer. Output 2 to 4 sentences in plain language about what the file does. ' +
+    'No code, no jargon, no bullet lists. Output only the explanation, nothing else.';
+const SYSTEM_PROMPT_ES = 'Estás explicando código a una persona no desarrolladora. Escribe entre 2 y 4 frases en lenguaje llano sobre qué hace el archivo. ' +
+    'Sin código, sin jerga, sin listas. Devuelve solo la explicación, nada más.';
+function buildSystemPrompt(language) {
+    return language === 'es' ? SYSTEM_PROMPT_ES : SYSTEM_PROMPT_EN;
+}
+/** Compose the single user-message body that goes to the model. The provider
+ *  adapter decides whether the system prompt rides along via a flag or gets
+ *  folded into this string (see `adapter.capabilities.systemPromptArg`). */
+function buildUserPrompt(input, adapter) {
+    const body = `${input.relPath}\n${input.contents}`;
+    if (adapter.capabilities.systemPromptArg)
+        return body;
+    // Provider does not accept a system-prompt flag; fold the instruction inline.
+    return `${buildSystemPrompt(input.language)}\n\n${body}`;
+}
+/** Cheapest model per provider for summary generation. Codex MUST run
+ *  `gpt-5.4-mini` (product decision: file summaries are non-critical and the
+ *  mini tier is the right cost target). Claude uses `haiku`. The per-provider
+ *  env overrides exist for ops escape hatches; the generic
+ *  `SPECRAILS_FILE_SUMMARY_MODEL` is honoured only when no provider-specific
+ *  override is set. */
+function defaultModelFor(adapter) {
+    if (adapter.id === 'claude') {
+        return process.env.SPECRAILS_FILE_SUMMARY_MODEL_CLAUDE
+            ?? process.env.SPECRAILS_FILE_SUMMARY_MODEL
+            ?? 'haiku';
+    }
+    if (adapter.id === 'codex') {
+        return process.env.SPECRAILS_FILE_SUMMARY_MODEL_CODEX ?? 'gpt-5.4-mini';
+    }
+    return process.env.SPECRAILS_FILE_SUMMARY_MODEL ?? adapter.defaultModel();
+}
+function createFileSummaryGenerator(opts) {
+    const adapter = opts.adapter;
+    const model = opts.model ?? defaultModelFor(adapter);
+    const timeoutMs = opts.timeoutMs ?? GENERATE_TIMEOUT_MS;
+    const spawn = opts.spawn ?? cli_prompt_1.spawnAiCli;
+    return async function generate(input, signal) {
+        const startedAt = Date.now();
+        if (signal?.aborted)
+            throw new Error('file-summary generator aborted before start');
+        const args = adapter.buildArgs('spec-gen', {
+            prompt: buildUserPrompt(input, adapter),
+            systemPrompt: adapter.capabilities.systemPromptArg ? buildSystemPrompt(input.language) : undefined,
+            model,
+            maxTurns: 1,
+        });
+        const child = spawn(adapter.binary, args, {
+            env: process.env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            cwd: opts.cwd,
+        });
+        return await new Promise((resolve, reject) => {
+            const events = [];
+            let fullText = '';
+            let stderrBuf = '';
+            let settled = false;
+            // Best-effort partial usage so a timeout/abort that killed the child AFTER
+            // the provider billed tokens still reports real spend (the manager stamps
+            // it onto the failed ai_invocations row instead of $0).
+            const buildPartial = () => {
+                if (events.length === 0)
+                    return undefined;
+                try {
+                    const { result, estimated } = (0, result_event_1.finaliseInvocationResult)(adapter, events, { fallbackModel: model });
+                    return {
+                        model: result.model ?? model,
+                        provider: adapter.id,
+                        costUsd: result.total_cost_usd ?? 0,
+                        costEstimated: estimated,
+                        tokensIn: result.tokens_in ?? 0,
+                        tokensOut: result.tokens_out ?? 0,
+                        tokensCacheRead: result.tokens_cache_read,
+                        tokensCacheCreate: result.tokens_cache_create,
+                        durationMs: result.duration_ms ?? (Date.now() - startedAt),
+                    };
+                }
+                catch {
+                    return undefined;
+                }
+            };
+            const rejectWithPartial = (message) => {
+                const err = new Error(message);
+                const partial = buildPartial();
+                if (partial)
+                    err.partial = partial;
+                reject(err);
+            };
+            let killGrace = null;
+            const killTree = () => {
+                const pid = child.pid;
+                if (pid) {
+                    try {
+                        (0, tree_kill_1.default)(pid, 'SIGTERM');
+                    }
+                    catch { /* best effort */ }
+                    killGrace = setTimeout(() => {
+                        try {
+                            (0, tree_kill_1.default)(pid, 'SIGKILL', () => { });
+                        }
+                        catch { /* best effort */ }
+                    }, 2000);
+                    if (typeof killGrace.unref === 'function')
+                        killGrace.unref();
+                }
+                else {
+                    try {
+                        child.kill('SIGTERM');
+                    }
+                    catch { /* best effort */ }
+                }
+            };
+            const onAbort = () => {
+                if (settled)
+                    return;
+                settled = true;
+                // treeKill (not child.kill) so the whole process tree dies — on Windows
+                // the CLI is wrapped in cmd.exe; on POSIX the CLI may have grandchildren.
+                killTree();
+                rejectWithPartial('file-summary generator aborted');
+            };
+            if (signal)
+                signal.addEventListener('abort', onAbort, { once: true });
+            const timer = setTimeout(() => {
+                if (settled)
+                    return;
+                settled = true;
+                killTree();
+                rejectWithPartial(`file-summary generator timeout after ${timeoutMs}ms`);
+            }, timeoutMs);
+            if (child.stderr) {
+                child.stderr.on('data', (chunk) => {
+                    stderrBuf += typeof chunk === 'string' ? chunk : chunk.toString('utf-8');
+                    if (stderrBuf.length > 8192)
+                        stderrBuf = stderrBuf.slice(-8192);
+                });
+            }
+            if (!child.stdout) {
+                clearTimeout(timer);
+                if (signal)
+                    signal.removeEventListener('abort', onAbort);
+                reject(new Error('file-summary generator: child has no stdout'));
+                return;
+            }
+            const reader = (0, readline_1.createInterface)({ input: child.stdout, crlfDelay: Infinity });
+            reader.on('line', (line) => {
+                const ev = adapter.parseStreamLine(line);
+                if (!ev)
+                    return;
+                events.push(ev);
+                if (ev.kind === 'text-delta')
+                    fullText += ev.text;
+            });
+            child.on('error', (err) => {
+                clearTimeout(timer);
+                if (signal)
+                    signal.removeEventListener('abort', onAbort);
+                if (killGrace) {
+                    clearTimeout(killGrace);
+                    killGrace = null;
+                }
+                if (settled)
+                    return;
+                settled = true;
+                reject(err);
+            });
+            child.on('close', (code) => {
+                clearTimeout(timer);
+                if (signal)
+                    signal.removeEventListener('abort', onAbort);
+                // A child that exits after a timeout-triggered SIGTERM clears the
+                // escalation so no stray SIGKILL lands on a recycled pid.
+                if (killGrace) {
+                    clearTimeout(killGrace);
+                    killGrace = null;
+                }
+                if (settled)
+                    return;
+                settled = true;
+                if (code !== 0) {
+                    const tail = stderrBuf.slice(-500);
+                    reject(new Error(`${adapter.binary} exit code=${code}; ${tail ? `stderr=${tail}` : 'no stderr'}`));
+                    return;
+                }
+                const summary = fullText.trim();
+                if (!summary) {
+                    reject(new Error(`${adapter.binary} returned empty summary text`));
+                    return;
+                }
+                const { result, estimated } = (0, result_event_1.finaliseInvocationResult)(adapter, events, { fallbackModel: model });
+                const durationMs = result.duration_ms ?? (Date.now() - startedAt);
+                resolve({
+                    summary,
+                    model: result.model ?? model,
+                    provider: adapter.id,
+                    costUsd: result.total_cost_usd ?? 0,
+                    costEstimated: estimated,
+                    tokensIn: result.tokens_in ?? 0,
+                    tokensOut: result.tokens_out ?? 0,
+                    tokensCacheRead: result.tokens_cache_read,
+                    tokensCacheCreate: result.tokens_cache_create,
+                    durationMs,
+                });
+            });
+        });
+    };
+}