@deepseek-harness-tui/dsh-tui 0.12.0 → 0.14.0

package/lib/types/backends/codex/translate/live.js

@@ -0,0 +1,315 @@
+import { t } from '../../../i18n.js';
+import { modeIdOf } from '../modes.js';
+import { arr, num, rec, str, text } from '../narrow.js';
+import { NOTIFY } from '../protocol/index.js';
+import { closeTurn, ensureAttempt, itemEvents, reportUsage } from './items.js';
+import { mcpStartupNotice, retryNotice, reviewNotice, turnEndReason, warningNotice } from './notices.js';
+import { tokenUsageOf } from './usage.js';
+/** Renderer urgency of one notification's batch. */
+export function wakeOf(method, events) {
+    if (method === NOTIFY.agentMessageDelta || method === NOTIFY.planDelta || method === NOTIFY.reasoningSummaryTextDelta
+        || method === NOTIFY.reasoningSummaryPartAdded || method === NOTIFY.reasoningTextDelta || method === NOTIFY.commandOutputDelta)
+        return 'frame';
+    return events.every(event => event.type === 'session.status' || event.type === 'pending.changed') ? 'none' : 'sync';
+}
+/** `turn/plan/updated` step status in the todo panel's vocabulary. */
+function todoStatus(status) {
+    return status === 'completed' ? 'completed' : status === 'inProgress' || status === 'in_progress' ? 'in_progress' : 'pending';
+}
+export function createLiveTranslator(ctx, settings) {
+    /** The window last announced (a change re-announces). */
+    let contextWindow;
+    /** Native turn id → our turn number (bounded): a straggler usage update
+     *  naming an already-closed turn is attributed to THAT turn, never folded
+     *  into whatever turn is live when it finally arrives. */
+    const turnNumbers = new Map();
+    /** Turns closed here (by `turn/completed` or a forced settle): their late
+     *  item, delta and usage traffic changes nothing (bounded, newest kept). */
+    const closedTurns = new Set();
+    const markClosed = (id) => {
+        if (id === undefined || id === '')
+            return;
+        closedTurns.add(id);
+        if (closedTurns.size > 64)
+            closedTurns.delete(closedTurns.values().next().value);
+    };
+    const deltaTo = (out, kind, textDelta, index) => {
+        if (textDelta === '' || !ctx.turnOpen)
+            return;
+        const attempt = ensureAttempt(ctx, out);
+        if (kind === 'reasoning')
+            attempt.streamedReasoning += textDelta;
+        else
+            attempt.streamedText += textDelta;
+        out.push({ type: 'assistant.delta', attemptId: attempt.id, index, time: ctx.now(), delta: { kind, text: textDelta } });
+    };
+    const notification = (method, params) => {
+        const out = [];
+        const now = ctx.now();
+        // A late notification of a turn already closed (an item that completes
+        // after a forced settle) must not reopen it as a phantom turn. Metering
+        // is the one exemption: a usage update is not turn content, and Codex
+        // reports a turn's final model call after `turn/completed` — dropping it
+        // would lose the session token totals, the tps readout and the context
+        // occupancy. A late arrival still books its totals and refreshes the
+        // context reading without reopening anything.
+        const turnOf = str(params.turnId) ?? (method === NOTIFY.turnStarted ? str(rec(params.turn)?.id) : undefined);
+        if (turnOf !== undefined && closedTurns.has(turnOf) && method !== NOTIFY.threadTokenUsageUpdated)
+            return out;
+        switch (method) {
+            case NOTIFY.turnStarted: {
+                const id = str(rec(params.turn)?.id);
+                if (id !== undefined)
+                    ctx.turnId = id;
+                return out;
+            }
+            case NOTIFY.turnCompleted: {
+                const turn = rec(params.turn) ?? {};
+                const id = str(turn.id);
+                // A repeated completion of a turn already closed changes nothing.
+                if (id !== undefined && closedTurns.has(id))
+                    return out;
+                if (id !== undefined && !ctx.turnOpen)
+                    ctx.turnId = id;
+                closeTurn(ctx, out, turnEndReason(turn), now);
+                if (id !== undefined) {
+                    turnNumbers.set(id, ctx.turn);
+                    if (turnNumbers.size > 64)
+                        turnNumbers.delete(turnNumbers.keys().next().value);
+                }
+                markClosed(id ?? ctx.turnId);
+                return out;
+            }
+            case NOTIFY.itemStarted:
+            case NOTIFY.itemCompleted: {
+                const item = rec(params.item);
+                if (item === undefined)
+                    return out;
+                const turnId = str(params.turnId);
+                if (turnId !== undefined && !ctx.turnOpen)
+                    ctx.turnId = turnId;
+                const events = itemEvents(item, method === NOTIFY.itemStarted ? 'started' : 'completed', ctx, now);
+                // itemEvents may have opened the turn and fixed its number: record the
+                // native-id → turn mapping AFTER it ran (a premature record would store
+                // the previous turn's number).
+                if (turnId !== undefined) {
+                    turnNumbers.set(turnId, ctx.turn);
+                    if (turnNumbers.size > 64)
+                        turnNumbers.delete(turnNumbers.keys().next().value);
+                }
+                return events;
+            }
+            case NOTIFY.agentMessageDelta:
+            case NOTIFY.planDelta:
+                deltaTo(out, 'text', str(params.delta) ?? '', 1);
+                return out;
+            case NOTIFY.reasoningSummaryTextDelta: {
+                const itemId = str(params.itemId) ?? '';
+                const attempt = ctx.attempt;
+                if (attempt !== undefined)
+                    attempt.summarized.add(itemId);
+                deltaTo(out, 'reasoning', str(params.delta) ?? '', 0);
+                return out;
+            }
+            case NOTIFY.reasoningSummaryPartAdded: {
+                const attempt = ctx.attempt;
+                if (attempt !== undefined && attempt.streamedReasoning !== '' && !attempt.streamedReasoning.endsWith('\n\n'))
+                    deltaTo(out, 'reasoning', '\n\n', 0);
+                return out;
+            }
+            case NOTIFY.reasoningTextDelta: {
+                // Raw reasoning shows only for an item that streams no summary.
+                const itemId = str(params.itemId) ?? '';
+                if (ctx.attempt?.summarized.has(itemId) === true)
+                    return out;
+                ctx.attempt?.rawReasoning.add(itemId);
+                deltaTo(out, 'reasoning', str(params.delta) ?? '', 0);
+                return out;
+            }
+            case NOTIFY.commandOutputDelta:
+            case NOTIFY.terminalInteraction: {
+                const callId = str(params.itemId);
+                if (callId !== undefined && ctx.openTools.has(callId)) {
+                    const value = method === NOTIFY.commandOutputDelta ? str(params.delta) : str(params.stdin);
+                    if (value !== undefined && value !== '')
+                        out.push({ type: 'tool.output', callId, text: method === NOTIFY.terminalInteraction ? `⏎ ${value}` : value, time: now });
+                }
+                return out;
+            }
+            case NOTIFY.mcpToolCallProgress: {
+                const callId = str(params.itemId);
+                const open = callId === undefined ? undefined : ctx.openTools.get(callId);
+                if (callId !== undefined && open !== undefined)
+                    out.push({ type: 'tool.progress', callId, elapsedMs: Math.max(0, now - open.startedAt) });
+                return out;
+            }
+            case NOTIFY.turnPlanUpdated: {
+                const items = arr(params.plan).flatMap(raw => {
+                    const step = rec(raw);
+                    const content = str(step?.step);
+                    return content === undefined ? [] : [{ content, status: todoStatus(str(step?.status)) }];
+                });
+                out.push({ type: 'todo.write', items });
+                return out;
+            }
+            case NOTIFY.threadTokenUsageUpdated: {
+                const { last, window } = tokenUsageOf(params);
+                if (window !== undefined && window !== contextWindow) {
+                    contextWindow = window;
+                    out.push({ type: 'context.capacity', contextWindow: window });
+                }
+                if (last !== undefined) {
+                    const nativeTurn = str(params.turnId);
+                    const attributed = nativeTurn === undefined || nativeTurn === ctx.turnId ? ctx.turn : turnNumbers.get(nativeTurn);
+                    reportUsage(ctx, out, last, now, attributed === undefined || attributed === ctx.turn ? undefined : { turn: attributed, stale: true });
+                }
+                const total = num(rec(rec(params.tokenUsage)?.last)?.totalTokens);
+                if (total !== undefined)
+                    out.push({ type: 'context.usage', used: Math.max(0, total - 12_000), ...(contextWindow === undefined ? {} : { max: Math.max(0, contextWindow - 12_000) }) });
+                return out;
+            }
+            case NOTIFY.threadStatusChanged: {
+                const status = rec(params.status);
+                switch (str(status?.type)) {
+                    case 'active': {
+                        const flags = arr(status?.activeFlags);
+                        out.push({ type: 'session.status', status: flags.includes('waitingOnApproval') || flags.includes('waitingOnUserInput') ? 'requires-action' : 'running' });
+                        return out;
+                    }
+                    case 'idle':
+                        out.push({ type: 'session.status', status: 'idle' });
+                        return out;
+                    case 'systemError':
+                        out.push({ type: 'session.status', status: 'idle' }, { type: 'notice', level: 'error', key: 'codex-system-error', text: t('codex-system-error') });
+                        return out;
+                    default:
+                        return out;
+                }
+            }
+            case NOTIFY.threadNameUpdated: {
+                const name = text(params.threadName);
+                if (name !== undefined)
+                    out.push({ type: 'session.title', title: name, source: 'auto' });
+                return out;
+            }
+            case NOTIFY.threadSettingsUpdated: {
+                const next = rec(params.threadSettings);
+                if (next === undefined)
+                    return out;
+                const model = str(next.model);
+                if (model !== undefined && model !== '' && model !== settings.model) {
+                    settings.model = model;
+                    ctx.model = model;
+                    out.push({ type: 'model.changed', model, ...(str(next.modelProvider) === undefined ? {} : { provider: str(next.modelProvider) }), source: 'settings' });
+                }
+                const effort = next.effort === null ? null : str(next.effort);
+                if (effort !== undefined && effort !== settings.effort) {
+                    settings.effort = effort;
+                    out.push({ type: 'effort.changed', effort });
+                }
+                if (next.approvalPolicy !== undefined)
+                    settings.approvalPolicy = next.approvalPolicy;
+                if (next.sandboxPolicy !== undefined)
+                    settings.sandboxPolicy = next.sandboxPolicy;
+                const permissionMode = modeIdOf(settings.approvalPolicy, settings.sandboxPolicy);
+                settings.permissionMode = permissionMode;
+                if (rec(next.collaborationMode) !== undefined)
+                    settings.collaborationMode = rec(next.collaborationMode);
+                const modeId = settings.collaborationMode?.mode === 'plan' ? 'plan' : permissionMode;
+                if (modeId !== settings.modeId) {
+                    settings.modeId = modeId;
+                    out.push({ type: 'mode.changed', modeId });
+                }
+                return out;
+            }
+            case NOTIFY.modelRerouted: {
+                const to = str(params.toModel);
+                if (to === undefined || to === '')
+                    return out;
+                settings.model = to;
+                ctx.model = to;
+                out.push({ type: 'model.changed', model: to, source: 'fallback' }, { type: 'notice', level: 'warning', key: 'reroute', text: t('codex-rerouted', { from: str(params.fromModel) ?? '', to, reason: str(params.reason) ?? '' }) });
+                return out;
+            }
+            case NOTIFY.error: {
+                const notice = retryNotice(params);
+                if (notice !== undefined)
+                    out.push(notice);
+                return out;
+            }
+            case NOTIFY.warning:
+            case NOTIFY.guardianWarning: {
+                const notice = warningNotice(method, params);
+                if (notice !== undefined)
+                    out.push(notice);
+                return out;
+            }
+            case NOTIFY.autoApprovalReviewStarted:
+            case NOTIFY.autoApprovalReviewCompleted: {
+                const notice = reviewNotice(method, params);
+                if (notice !== undefined)
+                    out.push(notice);
+                return out;
+            }
+            case NOTIFY.strictReviewRequired:
+                out.push({ type: 'notice', level: 'info', key: 'strict-review', text: t('codex-strict-review') });
+                return out;
+            case NOTIFY.threadCompacted:
+                if (!ctx.compactionSeen)
+                    out.push({ type: 'compaction.end', ok: true, contextReplaced: true, time: now });
+                return out;
+            case NOTIFY.threadClosed:
+            case NOTIFY.threadArchived:
+            case NOTIFY.threadDeleted:
+                out.push({ type: 'notice', level: 'warning', key: 'thread-state', text: t(method === NOTIFY.threadClosed ? 'codex-thread-closed' : method === NOTIFY.threadArchived ? 'codex-thread-archived' : 'codex-thread-deleted') });
+                return out;
+            case NOTIFY.mcpServerStartupStatusUpdated: {
+                const notice = mcpStartupNotice(params);
+                if (notice !== undefined)
+                    out.push(notice);
+                return out;
+            }
+            case NOTIFY.hookStarted:
+            case NOTIFY.hookCompleted: {
+                const run = rec(params.run);
+                const id = str(run?.id) ?? '';
+                const event = str(run?.eventName) ?? str(params.eventName) ?? '';
+                const status = str(run?.status);
+                const duration = num(run?.durationMs);
+                out.push({
+                    type: 'notice',
+                    level: 'info',
+                    key: `hook:${id}`,
+                    text: method === NOTIFY.hookStarted
+                        ? t('codex-hook-started', { event })
+                        : t(status === 'failed' || status === 'blocked' ? 'codex-hook-failed' : 'codex-hook-done', { event, duration: duration === undefined ? '' : `${Math.round(duration)} ms` }),
+                });
+                return out;
+            }
+            default:
+                return out;
+        }
+    };
+    return {
+        notification(method, params) {
+            try {
+                return notification(method, params);
+            }
+            catch (error) {
+                ctx.debug(`codex: translating ${method} failed (${error instanceof Error ? error.message : String(error)})`);
+                return [];
+            }
+        },
+        forceClose(reason) {
+            const out = [];
+            if (!ctx.turnOpen && ctx.attempt === undefined && ctx.openTools.size === 0)
+                return out;
+            closeTurn(ctx, out, reason, ctx.now());
+            // The force-closed turn's late traffic changes nothing.
+            markClosed(ctx.turnId);
+            return out;
+        },
+        ctx,
+        settings,
+    };
+}

package/lib/types/backends/codex/translate/notices.d.ts

@@ -0,0 +1,27 @@
+import type { AgentEvent, TurnEndReason } from '../../../agent/events.js';
+import { type Rec } from '../narrow.js';
+type Notice = Extract<AgentEvent, {
+    readonly type: 'notice';
+}>;
+/** The kebab-case name of a `codexErrorInfo` (a string or a one-key object). */
+export declare function errorCategory(info: unknown): string | undefined;
+/** Whether a configuration warning is the known sandbox fallback noise. */
+export declare function isBubblewrapNoise(summary: string): boolean;
+/** `error` with `willRetry`: one keyed warning per turn, updated in place. */
+export declare function retryNotice(params: Rec): Notice | undefined;
+/** `warning` / `guardianWarning` / `configWarning` / `deprecationNotice`. */
+export declare function warningNotice(method: string, params: Rec): Notice | undefined;
+/** The end reason of a `turn/completed` turn. */
+export declare function turnEndReason(turn: Rec): TurnEndReason;
+/**
+ * The actionable hint after a failed turn, by its error category (§9.1):
+ * sign in again, compact, wait for the limit, install the sandbox helper.
+ * The turn's own message is already on its notice row.
+ */
+export declare function failureHint(reason: TurnEndReason, platform?: string): Notice | undefined;
+/** `item/autoApprovalReview/*`: an info line while the auto-reviewer works. */
+export declare function reviewNotice(method: string, params: Rec): Notice | undefined;
+/** `mcpServer/startupStatus/updated` failing: one warning per server. */
+export declare function mcpStartupNotice(params: Rec): Notice | undefined;
+export {};
+//# sourceMappingURL=notices.d.ts.map

package/lib/types/backends/codex/translate/notices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notices.d.ts","sourceRoot":"","sources":["../../../../../src/backends/codex/translate/notices.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AAGzE,OAAO,EAAkB,KAAK,GAAG,EAAE,MAAM,cAAc,CAAA;AAEvD,KAAK,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC,CAAA;AAI9D,gFAAgF;AAChF,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAI/D;AAED,2EAA2E;AAC3E,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED,8EAA8E;AAC9E,wBAAgB,WAAW,CAAC,MAAM,EAAE,GAAG,GAAG,MAAM,GAAG,SAAS,CAI3D;AAED,6EAA6E;AAC7E,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,MAAM,GAAG,SAAS,CAO7E;AAED,iDAAiD;AACjD,wBAAgB,aAAa,CAAC,IAAI,EAAE,GAAG,GAAG,aAAa,CActD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,aAAa,EAAE,QAAQ,GAAE,MAAyB,GAAG,MAAM,GAAG,SAAS,CAe1G;AAED,+EAA+E;AAC/E,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,GAAG,MAAM,GAAG,SAAS,CAS5E;AAED,yEAAyE;AACzE,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,GAAG,GAAG,MAAM,GAAG,SAAS,CAKhE"}

package/lib/types/backends/codex/translate/notices.js

@@ -0,0 +1,99 @@
+/**
+ * Codex warnings and errors as localized notices (docs/codex-backend-design.md
+ * §7.5, §9.1). Every notice carries a `key`, so a repeat of the same
+ * condition replaces its toast instead of stacking a new one.
+ *
+ * Known start-up noise (the bubblewrap fallback warning on Linux) is not a
+ * notice: `/doctor` reports it.
+ */
+import { createHash } from 'node:crypto';
+import { t } from '../../../i18n.js';
+import { NOTIFY } from '../protocol/index.js';
+import { rec, str, text } from '../narrow.js';
+const digest = (value) => createHash('sha256').update(value).digest('hex').slice(0, 10);
+/** The kebab-case name of a `codexErrorInfo` (a string or a one-key object). */
+export function errorCategory(info) {
+    const name = typeof info === 'string' ? info : Object.keys(rec(info) ?? {})[0];
+    if (name === undefined || name === '')
+        return undefined;
+    return name.replace(/[A-Z]/gu, letter => `-${letter.toLowerCase()}`);
+}
+/** Whether a configuration warning is the known sandbox fallback noise. */
+export function isBubblewrapNoise(summary) {
+    return /bubblewrap/iu.test(summary);
+}
+/** `error` with `willRetry`: one keyed warning per turn, updated in place. */
+export function retryNotice(params) {
+    if (params.willRetry !== true)
+        return undefined;
+    const message = str(rec(params.error)?.message) ?? '';
+    return { type: 'notice', level: 'warning', key: `retry:${str(params.turnId) ?? ''}`, text: t('codex-retrying', { message }) };
+}
+/** `warning` / `guardianWarning` / `configWarning` / `deprecationNotice`. */
+export function warningNotice(method, params) {
+    const message = text(params.message) ?? text(params.summary);
+    if (message === undefined)
+        return undefined;
+    if (method === NOTIFY.configWarning && isBubblewrapNoise(message))
+        return undefined;
+    const details = text(params.details);
+    const body = details === undefined ? message : `${message} ${details}`;
+    return { type: 'notice', level: 'warning', key: `${method}:${digest(message)}`, text: body };
+}
+/** The end reason of a `turn/completed` turn. */
+export function turnEndReason(turn) {
+    switch (str(turn.status)) {
+        case 'completed':
+            return { kind: 'completed' };
+        case 'interrupted':
+            return { kind: 'interrupted' };
+        case 'failed': {
+            const error = rec(turn.error);
+            const category = errorCategory(error?.codexErrorInfo);
+            return { kind: 'error', message: str(error?.message) ?? t('codex-turn-failed'), ...(category === undefined ? {} : { category }) };
+        }
+        default:
+            return { kind: 'other', label: str(turn.status) ?? 'unknown' };
+    }
+}
+/**
+ * The actionable hint after a failed turn, by its error category (§9.1):
+ * sign in again, compact, wait for the limit, install the sandbox helper.
+ * The turn's own message is already on its notice row.
+ */
+export function failureHint(reason, platform = process.platform) {
+    if (reason.kind !== 'error')
+        return undefined;
+    switch (reason.category) {
+        case 'unauthorized':
+            return { type: 'notice', level: 'error', key: 'codex-hint:auth', text: t('codex-hint-unauthorized') };
+        case 'context-window-exceeded':
+            return { type: 'notice', level: 'warning', key: 'codex-hint:context', text: t('codex-hint-context') };
+        case 'usage-limit-exceeded':
+        case 'rate-limit-exceeded':
+            return { type: 'notice', level: 'warning', key: 'codex-hint:limit', text: t('codex-hint-limit') };
+        case 'sandbox-error':
+            return platform === 'linux' ? { type: 'notice', level: 'warning', key: 'codex-hint:sandbox', text: t('codex-hint-sandbox') } : undefined;
+        default:
+            return undefined;
+    }
+}
+/** `item/autoApprovalReview/*`: an info line while the auto-reviewer works. */
+export function reviewNotice(method, params) {
+    const review = rec(params.review);
+    const id = str(params.reviewId) ?? '';
+    if (method === NOTIFY.autoApprovalReviewStarted) {
+        return { type: 'notice', level: 'info', key: `auto-review:${id}`, text: t('codex-auto-review-started') };
+    }
+    const status = str(review?.status) ?? str(params.status);
+    const outcome = status === 'approved' ? t('codex-auto-review-approved') : status === 'denied' ? t('codex-auto-review-denied') : t('codex-auto-review-ended');
+    return { type: 'notice', level: 'info', key: `auto-review:${id}`, text: outcome };
+}
+/** `mcpServer/startupStatus/updated` failing: one warning per server. */
+export function mcpStartupNotice(params) {
+    const status = str(params.status);
+    const name = str(params.name) ?? '';
+    if (status !== 'failed' && status !== 'error')
+        return undefined;
+    return { type: 'notice', level: 'warning', key: `mcp:${name}`, text: t('codex-mcp-failed', { name, error: str(params.error) ?? '' }) };
+}

package/lib/types/backends/codex/translate/presentation.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Codex tool items as tool cards (docs/codex-backend-design.md §7.4, §8):
+ * the tool name the transcript records, its arguments, and the card shape
+ * each call and result renders as, in the backend-neutral presentation
+ * vocabulary. The UI never picks a card by tool name; this module does,
+ * from the item itself.
+ *
+ * Titles carry only the item's own text (commands, paths, queries): the
+ * localized tool name comes from `displayKey`, so a language switch repaints.
+ *
+ * Diffs: an added file's `diff` is its content, a deleted one's is the old
+ * content (C0 V13); updates keep their unified hunks and real line numbers.
+ */
+import type { ContentBlockView } from '../../../agent/events.js';
+import type { ToolCallPresentation, ToolResultPresentation } from '../../../agent/presentation.js';
+import { type Rec } from '../narrow.js';
+/** The item types this module renders as tool cards. */
+export declare const TOOL_ITEM_TYPES: ReadonlySet<string>;
+/** How a tool item's call is recorded. */
+export interface CodexToolCall {
+    readonly name: string;
+    readonly argsJson: string;
+    readonly presentation?: ToolCallPresentation;
+}
+/** How a tool item's settled result is recorded. */
+export interface CodexToolResult {
+    readonly isError: boolean;
+    readonly text: string;
+    readonly content: readonly ContentBlockView[];
+    /** Set exactly when `isError`: the failure's own words, or a fixed one. */
+    readonly errorText?: string;
+    readonly structured?: unknown;
+    readonly presentation?: ToolResultPresentation;
+}
+/** Fixed result texts the translator localizes (the caller passes `t`). */
+export interface ResultWords {
+    readonly declined: string;
+    readonly failed: string;
+}
+/** Rebuild old/new text from an unheaded unified hunk (the C1 fallback). */
+export declare function hunkTexts(patch: string): {
+    oldText: string;
+    newText: string;
+};
+/** How a tool item's call is recorded; undefined for a non-tool item. */
+export declare function toolCallOf(item: Rec, cwd: string): CodexToolCall | undefined;
+/** How a settled tool item's result is recorded. */
+export declare function toolResultOf(item: Rec, cwd: string, words: ResultWords): CodexToolResult;
+//# sourceMappingURL=presentation.d.ts.map

package/lib/types/backends/codex/translate/presentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presentation.d.ts","sourceRoot":"","sources":["../../../../../src/backends/codex/translate/presentation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAA;AAEhE,OAAO,KAAK,EAAE,oBAAoB,EAAwB,sBAAsB,EAAE,MAAM,gCAAgC,CAAA;AAExH,OAAO,EAAsB,KAAK,GAAG,EAAE,MAAM,cAAc,CAAA;AAG3D,wDAAwD;AACxD,eAAO,MAAM,eAAe,EAAE,WAAW,CAAC,MAAM,CAG9C,CAAA;AAEF,0CAA0C;AAC1C,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,YAAY,CAAC,EAAE,oBAAoB,CAAA;CAC7C;AAED,oDAAoD;AACpD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,SAAS,gBAAgB,EAAE,CAAA;IAC7C,2EAA2E;IAC3E,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAA;IAC7B,QAAQ,CAAC,YAAY,CAAC,EAAE,sBAAsB,CAAA;CAC/C;AAED,2EAA2E;AAC3E,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAiCD,4EAA4E;AAC5E,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAmB7E;AAuCD,yEAAyE;AACzE,wBAAgB,UAAU,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAuD5E;AAUD,oDAAoD;AACpD,wBAAgB,YAAY,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG,eAAe,CAoExF"}