@undefineds.co/linx 0.2.19 → 0.2.22

package/vendor/agent-runtime/dist/auto-mode.js

@@ -0,0 +1,1498 @@
+export function autoModeApprovalActionUri(request) {
+    if (request.kind === 'command-approval') {
+        return 'https://undefineds.co/ns#commandExecution';
+    }
+    if (request.kind === 'file-change-approval') {
+        return 'https://undefineds.co/ns#fileChange';
+    }
+    if (request.kind === 'permissions-approval') {
+        return 'https://undefineds.co/ns#permissionRequest';
+    }
+    return 'https://undefineds.co/ns#runtimeApproval';
+}
+export function autoModeApprovalToolName(request) {
+    if (request.kind === 'command-approval') {
+        return 'commandExecution';
+    }
+    if (request.kind === 'file-change-approval') {
+        return 'fileChange';
+    }
+    if (request.kind === 'permissions-approval') {
+        return 'permissionRequest';
+    }
+    return 'runtimeApproval';
+}
+export function autoModeApprovalRisk(request) {
+    if (request.kind === 'permissions-approval' || request.kind === 'file-change-approval') {
+        return 'high';
+    }
+    return 'medium';
+}
+export function autoModeApprovalRequestMessage(request) {
+    if (request.kind === 'command-approval') {
+        return request.command?.trim() || request.message;
+    }
+    if (request.kind === 'file-change-approval') {
+        return request.reason?.trim() || request.message;
+    }
+    return request.message;
+}
+export const DEFAULT_AUTO_MODE_SECRETARY_REACTION_WINDOW_MS = 5_000;
+export const MIN_AUTO_MODE_SECRETARY_REACTION_WINDOW_MS = 5_000;
+export const MAX_AUTO_MODE_SECRETARY_REACTION_WINDOW_MS = 60_000;
+export const AUTO_MODE_HOME_DIRNAME = 'auto-mode';
+export const AUTO_MODE_SESSIONS_DIRNAME = 'sessions';
+export const AUTO_MODE_SESSION_FILE_NAME = 'session.json';
+export const AUTO_MODE_EVENTS_FILE_NAME = 'events.jsonl';
+function fallbackRandomId() {
+    return Math.random().toString(36).slice(2, 10).padEnd(8, '0');
+}
+function extractAutoModeJsonText(value, depth = 0) {
+    if (depth > 4) {
+        return undefined;
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        const parts = value
+            .map((item) => extractAutoModeJsonText(item, depth + 1))
+            .filter((item) => typeof item === 'string' && item.length > 0);
+        return parts.length > 0 ? parts.join('') : undefined;
+    }
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    return firstNonEmpty([
+        extractAutoModeJsonText(value.text, depth + 1),
+        extractAutoModeJsonText(value.delta, depth + 1),
+        extractAutoModeJsonText(value.message, depth + 1),
+        extractAutoModeJsonText(value.content, depth + 1),
+        extractAutoModeJsonText(value.result, depth + 1),
+        extractAutoModeJsonText(value.summary, depth + 1),
+        extractAutoModeJsonText(value.error, depth + 1),
+    ]);
+}
+function extractAutoModeJsonArguments(value) {
+    if (isRecord(value)) {
+        return value;
+    }
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(value);
+        return isRecord(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function normalizeAutoModeUserInputOption(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const label = firstNonEmpty([
+        typeof value.label === 'string' ? value.label : undefined,
+        typeof value.value === 'string' ? value.value : undefined,
+    ]);
+    if (!label) {
+        return null;
+    }
+    const description = firstNonEmpty([
+        typeof value.description === 'string' ? value.description : undefined,
+        typeof value.details === 'string' ? value.details : undefined,
+    ]);
+    return {
+        label,
+        ...(description ? { description } : {}),
+    };
+}
+export function normalizeAutoModeUserInputQuestion(value, fallbackId = 'question-1') {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const header = firstNonEmpty([
+        typeof value.header === 'string' ? value.header : undefined,
+        typeof value.title === 'string' ? value.title : undefined,
+        typeof value.label === 'string' ? value.label : undefined,
+    ]) ?? 'Question';
+    const question = firstNonEmpty([
+        typeof value.question === 'string' ? value.question : undefined,
+        typeof value.prompt === 'string' ? value.prompt : undefined,
+        typeof value.message === 'string' ? value.message : undefined,
+        header,
+    ]) ?? header;
+    const options = Array.isArray(value.options)
+        ? value.options
+            .map((option) => normalizeAutoModeUserInputOption(option))
+            .filter((option) => option !== null)
+        : [];
+    return {
+        id: firstNonEmpty([typeof value.id === 'string' ? value.id : undefined, fallbackId]) ?? fallbackId,
+        header,
+        question,
+        options,
+    };
+}
+export function resolveAutoModeQuestionAnswer(question, answer) {
+    const normalized = answer.trim();
+    if (!normalized) {
+        return [];
+    }
+    if (question.options.length > 0 && /^\d+$/u.test(normalized)) {
+        const index = Number(normalized) - 1;
+        const option = question.options[index];
+        if (option?.label) {
+            return [option.label];
+        }
+    }
+    return [normalized];
+}
+function recordFromUnknown(value) {
+    return isRecord(value) ? value : null;
+}
+function extractAcpCommand(value) {
+    if (typeof value === 'string' && value.trim()) {
+        return value.trim();
+    }
+    const record = recordFromUnknown(value);
+    if (!record) {
+        return undefined;
+    }
+    const command = firstNonEmpty([
+        typeof record.command === 'string' ? record.command : undefined,
+        typeof record.cmd === 'string' ? record.cmd : undefined,
+    ]);
+    const args = Array.isArray(record.args)
+        ? record.args.filter((item) => typeof item === 'string' && item.trim().length > 0)
+        : [];
+    if (command && args.length > 0) {
+        return `${command} ${args.join(' ')}`;
+    }
+    return command ?? extractAutoModeJsonText(record);
+}
+function normalizeAcpPermissionOptions(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((item) => isRecord(item));
+}
+export function normalizeAutoModeApprovalOptions(value) {
+    return normalizeAcpPermissionOptions(value)
+        .map((option) => {
+        const optionId = typeof option.optionId === 'string' && option.optionId.trim()
+            ? option.optionId.trim()
+            : undefined;
+        const label = firstNonEmpty([
+            typeof option.name === 'string' ? option.name : undefined,
+            typeof option.label === 'string' ? option.label : undefined,
+            optionId,
+        ]);
+        if (!optionId || !label) {
+            return null;
+        }
+        const kind = typeof option.kind === 'string' && option.kind.trim()
+            ? option.kind.trim()
+            : undefined;
+        const description = firstNonEmpty([
+            typeof option.description === 'string' ? option.description : undefined,
+            typeof option.detail === 'string' ? option.detail : undefined,
+        ]);
+        return {
+            optionId,
+            label,
+            ...(kind ? { kind } : {}),
+            ...(description ? { description } : {}),
+        };
+    })
+        .filter((option) => option !== null);
+}
+function normalizeDurationMs(value, unit) {
+    const numeric = typeof value === 'number'
+        ? value
+        : typeof value === 'string' && value.trim()
+            ? Number(value)
+            : Number.NaN;
+    if (!Number.isFinite(numeric) || numeric <= 0) {
+        return undefined;
+    }
+    const milliseconds = unit === 'ms'
+        ? numeric
+        : unit === 'seconds'
+            ? numeric * 1000
+            : numeric > 10_000
+                ? numeric
+                : numeric * 1000;
+    return Math.round(milliseconds);
+}
+function normalizeIsoDatetime(value) {
+    if (value instanceof Date) {
+        return Number.isFinite(value.getTime()) ? value.toISOString() : undefined;
+    }
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        const date = new Date(value);
+        return Number.isFinite(date.getTime()) ? date.toISOString() : undefined;
+    }
+    if (typeof value !== 'string' || !value.trim()) {
+        return undefined;
+    }
+    const date = new Date(value);
+    return Number.isFinite(date.getTime()) ? date.toISOString() : undefined;
+}
+function extractAutoModeApprovalTimeoutMs(params, raw) {
+    const meta = isRecord(params._meta)
+        ? params._meta
+        : isRecord(raw._meta)
+            ? raw._meta
+            : {};
+    return normalizeDurationMs(params.timeoutMs ?? meta.timeoutMs, 'ms')
+        ?? normalizeDurationMs(params.timeoutMillis ?? params.timeoutMilliseconds ?? meta.timeoutMillis ?? meta.timeoutMilliseconds, 'ms')
+        ?? normalizeDurationMs(params.timeoutSeconds ?? params.timeoutSec ?? meta.timeoutSeconds ?? meta.timeoutSec, 'seconds')
+        ?? normalizeDurationMs(params.timeout ?? meta.timeout, 'auto');
+}
+function extractAutoModeApprovalExpiresAt(params, raw) {
+    const meta = isRecord(params._meta)
+        ? params._meta
+        : isRecord(raw._meta)
+            ? raw._meta
+            : {};
+    return normalizeIsoDatetime(params.expiresAt ?? params.deadline ?? params.expires ?? meta.expiresAt ?? meta.deadline ?? meta.expires);
+}
+function extractAutoModeApprovalMetadata(raw, params) {
+    const approvalOptions = normalizeAutoModeApprovalOptions(params.options);
+    const timeoutMs = extractAutoModeApprovalTimeoutMs(params, raw);
+    const expiresAt = extractAutoModeApprovalExpiresAt(params, raw);
+    return {
+        ...(approvalOptions.length > 0 ? { approvalOptions } : {}),
+        ...(timeoutMs ? { timeoutMs } : {}),
+        ...(expiresAt ? { expiresAt } : {}),
+    };
+}
+function selectAcpPermissionOption(options, decision) {
+    if (decision === 'cancel') {
+        return undefined;
+    }
+    const preferredKinds = decision === 'accept'
+        ? ['allow_once', 'allow_always']
+        : decision === 'accept_for_session'
+            ? ['allow_always', 'allow_once']
+            : ['reject_once', 'reject_always'];
+    for (const kind of preferredKinds) {
+        const match = options.find((option) => option.kind === kind && typeof option.optionId === 'string');
+        if (match && typeof match.optionId === 'string') {
+            return match.optionId;
+        }
+    }
+    const preferredNames = decision === 'decline'
+        ? ['reject', 'deny', 'decline', 'no']
+        : ['allow', 'approve', 'yes'];
+    for (const option of options) {
+        if (typeof option.optionId !== 'string' || typeof option.name !== 'string') {
+            continue;
+        }
+        const name = option.name.toLowerCase();
+        if (preferredNames.some((token) => name.includes(token))) {
+            return option.optionId;
+        }
+    }
+    const fallback = decision === 'decline'
+        ? options.find((option) => typeof option.optionId === 'string')
+        : options.find((option) => typeof option.optionId === 'string');
+    return typeof fallback?.optionId === 'string' ? fallback.optionId : undefined;
+}
+export function createAutoModeSessionId(options = {}) {
+    const now = options.now ?? new Date();
+    const randomId = (options.randomId?.trim() || globalThis.crypto?.randomUUID?.() || fallbackRandomId()).slice(0, 8);
+    const stamp = now.toISOString().replace(/[:.]/g, '-');
+    return `auto_${stamp}_${randomId}`;
+}
+export function normalizeAutoModeCredentialSource(_source) {
+    return 'cloud';
+}
+export function shouldAttemptCloudCredentialProbe(_requestedSource, _localAuthStatus) {
+    return true;
+}
+export function formatAutoModeAutoFallbackMessage(localMessage, detail) {
+    return `${localMessage} Cloud credential fallback unavailable: ${detail}`;
+}
+export function resolveAutoModeCredentialSourceResolution(input) {
+    const requestedSource = normalizeAutoModeCredentialSource(input.requestedSource);
+    const cloudCredentialProbe = input.cloudCredentialProbe;
+    if (cloudCredentialProbe?.status === 'available') {
+        return {
+            requestedSource,
+            resolvedSource: 'cloud',
+            authStatus: { state: 'authenticated' },
+        };
+    }
+    return {
+        requestedSource,
+        authStatus: { state: 'unauthenticated', message: cloudCredentialProbe?.message },
+        error: cloudCredentialProbe?.message ?? 'Cloud credential resolution unavailable.',
+    };
+}
+export function resolveAutoModeAutoApprovalDecision(input) {
+    const { mode, request } = input;
+    if (request.kind === 'command-approval') {
+        if (mode === 'auto') {
+            return 'accept_for_session';
+        }
+        if (mode === 'smart' && isTrustedAutoModeCommand(request.command)) {
+            return 'accept';
+        }
+        return null;
+    }
+    if (request.kind === 'file-change-approval') {
+        if (mode === 'auto') {
+            return 'accept_for_session';
+        }
+        if (mode === 'smart') {
+            return 'accept';
+        }
+        return null;
+    }
+    if (request.kind === 'permissions-approval') {
+        if (mode === 'auto') {
+            return 'accept_for_session';
+        }
+        return null;
+    }
+    return null;
+}
+export function createFallbackAutoModeSecretaryRecommendation(input) {
+    if (input.mode === 'manual' || input.request.kind === 'user-input') {
+        return null;
+    }
+    const decision = resolveAutoModeAutoApprovalDecision({
+        mode: input.mode,
+        request: input.request,
+    });
+    const secretaryDecision = decision === 'accept_for_session' ? 'accept' : decision;
+    if (!secretaryDecision) {
+        return null;
+    }
+    return {
+        kind: input.request.kind,
+        canAutoDecide: true,
+        decision: secretaryDecision,
+        confidence: input.mode === 'auto' ? 0.7 : 0.6,
+        reason: 'Matched local fallback policy while AI secretary was unavailable.',
+        reactionWindowMs: 0,
+        source: 'fallback',
+    };
+}
+export function parseAutoModeSecretaryRecommendation(text, options) {
+    const raw = parseJsonObjectFromText(text);
+    if (!raw) {
+        return null;
+    }
+    const canAutoDecide = booleanFromUnknown(raw.canAutoDecide
+        ?? raw.can_auto_decide
+        ?? raw.autoApprove
+        ?? raw.auto_approve
+        ?? raw.canAnswer
+        ?? raw.can_answer);
+    const confidence = normalizeConfidence(raw.confidence ?? raw.confidenceScore ?? raw.confidence_score);
+    const reason = stringFromUnknown(raw.reason ?? raw.rationale ?? raw.explanation);
+    const fallbackReactionWindowMs = options.defaultReactionWindowMs ?? DEFAULT_AUTO_MODE_SECRETARY_REACTION_WINDOW_MS;
+    const reactionWindowMs = confidence !== undefined
+        ? computeAutoModeSecretaryReactionWindowMs(confidence, fallbackReactionWindowMs)
+        : normalizeReactionWindowMs(raw.reactionWindowMs
+            ?? raw.reaction_window_ms
+            ?? raw.reviewWindowMs
+            ?? raw.review_window_ms
+            ?? raw.autoDecisionDelayMs
+            ?? raw.auto_decision_delay_ms, fallbackReactionWindowMs);
+    if (options.request.kind === 'user-input') {
+        const answers = normalizeSecretaryUserInputAnswers(options.request.questions, raw.answers ?? raw.answer ?? raw.userInputAnswers ?? raw.user_input_answers);
+        return {
+            kind: 'user-input',
+            canAutoDecide: canAutoDecide === true && !!answers,
+            ...(confidence !== undefined ? { confidence } : {}),
+            ...(reason ? { reason } : {}),
+            ...(reactionWindowMs !== undefined ? { reactionWindowMs } : {}),
+            ...(answers ? { answers } : {}),
+            source: 'model',
+        };
+    }
+    const decision = normalizeSecretaryApprovalDecision(raw.decision ?? raw.recommendedDecision ?? raw.recommended_decision);
+    if (!decision) {
+        return {
+            kind: options.request.kind,
+            canAutoDecide: false,
+            ...(confidence !== undefined ? { confidence } : {}),
+            ...(reason ? { reason } : {}),
+            ...(reactionWindowMs !== undefined ? { reactionWindowMs } : {}),
+            source: 'model',
+        };
+    }
+    return {
+        kind: options.request.kind,
+        canAutoDecide: canAutoDecide === true,
+        decision,
+        ...(confidence !== undefined ? { confidence } : {}),
+        ...(reason ? { reason } : {}),
+        ...(reactionWindowMs !== undefined ? { reactionWindowMs } : {}),
+        source: 'model',
+    };
+}
+export function autoModeApprovalDecisionLabel(decision) {
+    if (decision === 'accept') {
+        return 'Allow once';
+    }
+    if (decision === 'accept_for_session') {
+        return 'Grant';
+    }
+    if (decision === 'decline') {
+        return 'Deny';
+    }
+    return 'Cancel';
+}
+export function autoModeUserInputAnswersSummary(answers) {
+    return Object.entries(answers)
+        .map(([key, value]) => `${key}: ${value.answers.join(', ')}`)
+        .join('; ');
+}
+export function parseAutoModeGrantCoverageDecision(text) {
+    const raw = parseJsonObjectFromText(text);
+    if (!raw) {
+        return null;
+    }
+    const covers = booleanFromUnknown(raw.covers ?? raw.covered ?? raw.applies ?? raw.allowed);
+    if (covers === undefined) {
+        return null;
+    }
+    const confidence = normalizeConfidence(raw.confidence ?? raw.confidenceScore ?? raw.confidence_score);
+    const reason = stringFromUnknown(raw.reason ?? raw.rationale ?? raw.explanation);
+    return {
+        covers,
+        ...(confidence !== undefined ? { confidence } : {}),
+        ...(reason ? { reason } : {}),
+        source: 'model',
+    };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function stringFromUnknown(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function booleanFromUnknown(value) {
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        if (['true', 'yes', 'y', '1'].includes(normalized)) {
+            return true;
+        }
+        if (['false', 'no', 'n', '0'].includes(normalized)) {
+            return false;
+        }
+    }
+    return undefined;
+}
+function normalizeConfidence(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        if (value > 1 && value <= 100) {
+            return Math.max(0, Math.min(1, value / 100));
+        }
+        return Math.max(0, Math.min(1, value));
+    }
+    if (typeof value === 'string' && value.trim()) {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? normalizeConfidence(parsed) : undefined;
+    }
+    return undefined;
+}
+function normalizeReactionWindowMs(value, fallback) {
+    const parsed = normalizeDurationMs(value ?? fallback, 'ms');
+    if (parsed === undefined) {
+        return undefined;
+    }
+    return Math.max(0, Math.min(MAX_AUTO_MODE_SECRETARY_REACTION_WINDOW_MS, parsed));
+}
+export function computeAutoModeSecretaryReactionWindowMs(confidence, fallback = DEFAULT_AUTO_MODE_SECRETARY_REACTION_WINDOW_MS) {
+    if (typeof confidence !== 'number' || !Number.isFinite(confidence)) {
+        return Math.max(0, Math.min(MAX_AUTO_MODE_SECRETARY_REACTION_WINDOW_MS, fallback));
+    }
+    const normalized = Math.max(0, Math.min(1, confidence));
+    const window = Math.round(MIN_AUTO_MODE_SECRETARY_REACTION_WINDOW_MS
+        + (1 - normalized) * (MAX_AUTO_MODE_SECRETARY_REACTION_WINDOW_MS - MIN_AUTO_MODE_SECRETARY_REACTION_WINDOW_MS));
+    return Math.max(MIN_AUTO_MODE_SECRETARY_REACTION_WINDOW_MS, Math.min(MAX_AUTO_MODE_SECRETARY_REACTION_WINDOW_MS, window));
+}
+function normalizeSecretaryApprovalDecision(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase().replace(/-/g, '_');
+    if (['accept', 'allow', 'allow_once', 'approve', 'yes', 'accept_for_session', 'allow_always', 'grant', 'session', 'approve_for_session'].includes(normalized)) {
+        return 'accept';
+    }
+    if (['decline', 'deny', 'reject', 'reject_once', 'reject_always', 'no'].includes(normalized)) {
+        return 'decline';
+    }
+    if (['cancel', 'abort'].includes(normalized)) {
+        return 'cancel';
+    }
+    return undefined;
+}
+function parseJsonObjectFromText(text) {
+    const trimmed = text.trim();
+    if (!trimmed) {
+        return null;
+    }
+    for (const candidate of [
+        trimmed,
+        extractFencedJson(trimmed),
+        extractBracedJson(trimmed),
+    ]) {
+        if (!candidate) {
+            continue;
+        }
+        try {
+            const parsed = JSON.parse(candidate);
+            return recordFromUnknown(parsed);
+        }
+        catch {
+            // Try the next extraction shape.
+        }
+    }
+    return null;
+}
+function extractFencedJson(text) {
+    const match = text.match(/```(?:json)?\s*([\s\S]*?)```/iu);
+    return match?.[1]?.trim() || null;
+}
+function extractBracedJson(text) {
+    const start = text.indexOf('{');
+    const end = text.lastIndexOf('}');
+    return start !== -1 && end > start ? text.slice(start, end + 1) : null;
+}
+function normalizeSecretaryUserInputAnswers(questions, rawAnswers) {
+    const source = recordFromUnknown(rawAnswers);
+    if (!source) {
+        return undefined;
+    }
+    const answers = {};
+    for (const question of questions) {
+        const raw = source[question.id] ?? source[question.header] ?? source[question.question];
+        const normalizedAnswers = normalizeSecretaryAnswerValues(raw);
+        if (normalizedAnswers.length > 0) {
+            answers[question.id] = { answers: normalizedAnswers };
+        }
+    }
+    return Object.keys(answers).length > 0 ? answers : undefined;
+}
+function normalizeSecretaryAnswerValues(value) {
+    const answerRecord = recordFromUnknown(value);
+    if (answerRecord) {
+        return normalizeSecretaryAnswerValues(answerRecord.answers ?? answerRecord.value ?? answerRecord.answer);
+    }
+    const values = Array.isArray(value) ? value : [value];
+    return values
+        .map((entry) => typeof entry === 'string' ? entry.trim() : '')
+        .filter(Boolean);
+}
+function firstNonEmpty(values) {
+    for (const value of values) {
+        if (typeof value === 'string' && value.trim()) {
+            return value.trim();
+        }
+    }
+    return undefined;
+}
+function normalizeAutoModeAuthText(value, depth = 0) {
+    if (depth > 5) {
+        return undefined;
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        const parts = value
+            .map((item) => normalizeAutoModeAuthText(item, depth + 1))
+            .filter((item) => typeof item === 'string' && item.trim().length > 0);
+        return parts.length > 0 ? parts.join(' ') : undefined;
+    }
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    return firstNonEmpty([
+        normalizeAutoModeAuthText(value.message, depth + 1),
+        normalizeAutoModeAuthText(value.error, depth + 1),
+        normalizeAutoModeAuthText(value.result, depth + 1),
+        normalizeAutoModeAuthText(value.text, depth + 1),
+        normalizeAutoModeAuthText(value.reason, depth + 1),
+        normalizeAutoModeAuthText(value.content, depth + 1),
+        normalizeAutoModeAuthText(value.summary, depth + 1),
+    ]);
+}
+export function getAutoModeAuthLoginCommand(backend) {
+    if (backend === 'claude') {
+        return 'claude auth login';
+    }
+    if (backend === 'codex') {
+        return 'codex login';
+    }
+    return null;
+}
+export function formatAutoModeBackendAuthMessage(backend, detail) {
+    const command = getAutoModeAuthLoginCommand(backend);
+    const label = backend === 'claude'
+        ? 'Claude Code'
+        : backend === 'codebuddy'
+            ? 'CodeBuddy Code'
+            : 'Codex';
+    if (backend === 'codebuddy') {
+        return detail
+            ? `${label} is not authenticated. Open \`codebuddy\` and complete login first. Native message: ${detail}`
+            : `${label} is not authenticated. Open \`codebuddy\` and complete login first.`;
+    }
+    return detail
+        ? `${label} is not authenticated. Run \`${command}\` and try again. Native message: ${detail}`
+        : `${label} is not authenticated. Run \`${command}\` and try again.`;
+}
+export function looksLikeAutoModeAuthFailureText(text) {
+    return [
+        /\bnot logged in\b/iu,
+        /\bauthentication_failed\b/iu,
+        /\bunauthenticated\b/iu,
+        /\bauthentication required\b/iu,
+        /\bplease run \/login\b/iu,
+        /\bplease sign in\b/iu,
+        /\bsign in first\b/iu,
+        /\blogin required\b/iu,
+        /\bunauthorized\b/iu,
+        /\binvalid api key\b/iu,
+    ].some((pattern) => pattern.test(text));
+}
+export function parseAutoModeClaudeAuthStatus(stdout) {
+    const payload = parseAutoModeJsonLine(stdout.trim());
+    if (!payload || typeof payload.loggedIn !== 'boolean') {
+        return { state: 'unknown' };
+    }
+    return payload.loggedIn
+        ? { state: 'authenticated' }
+        : { state: 'unauthenticated', message: formatAutoModeBackendAuthMessage('claude') };
+}
+export function detectAutoModeAuthFailure(backend, line) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const payload = parseAutoModeJsonLine(trimmed);
+    if (payload) {
+        if (backend === 'claude' && payload.error === 'authentication_failed') {
+            const detail = normalizeAutoModeAuthText(payload) ?? 'authentication_failed';
+            return { message: formatAutoModeBackendAuthMessage(backend, detail) };
+        }
+        if (backend === 'claude' && payload.loggedIn === false) {
+            return { message: formatAutoModeBackendAuthMessage(backend) };
+        }
+        if (payload.error) {
+            const detail = normalizeAutoModeAuthText(payload.error) ?? normalizeAutoModeAuthText(payload);
+            if (detail && looksLikeAutoModeAuthFailureText(detail)) {
+                return { message: formatAutoModeBackendAuthMessage(backend, detail) };
+            }
+        }
+        if (payload.is_error === true) {
+            const detail = normalizeAutoModeAuthText(payload);
+            if (detail && looksLikeAutoModeAuthFailureText(detail)) {
+                return { message: formatAutoModeBackendAuthMessage(backend, detail) };
+            }
+        }
+        const detail = normalizeAutoModeAuthText(payload);
+        if (detail && looksLikeAutoModeAuthFailureText(detail)) {
+            return { message: formatAutoModeBackendAuthMessage(backend, detail) };
+        }
+    }
+    if (!looksLikeAutoModeAuthFailureText(trimmed)) {
+        return null;
+    }
+    return { message: formatAutoModeBackendAuthMessage(backend, trimmed) };
+}
+export function parseAutoModeJsonLine(line) {
+    try {
+        const parsed = JSON.parse(line);
+        return isRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function extractAutoModeSessionIdFromJsonLine(line) {
+    const json = parseAutoModeJsonLine(line);
+    if (!json) {
+        return undefined;
+    }
+    return firstNonEmpty([
+        typeof json.session_id === 'string' ? json.session_id : undefined,
+        typeof json.sessionId === 'string' ? json.sessionId : undefined,
+        isRecord(json.message) && typeof json.message.session_id === 'string' ? json.message.session_id : undefined,
+        isRecord(json.message) && typeof json.message.sessionId === 'string' ? json.message.sessionId : undefined,
+    ]);
+}
+export function isTrustedAutoModeCommand(command) {
+    if (!command) {
+        return false;
+    }
+    const normalized = command.trim();
+    const safePatterns = [
+        /^pwd(?:\s|$)/,
+        /^ls(?:\s|$)/,
+        /^cat(?:\s|$)/,
+        /^sed(?:\s|$)/,
+        /^head(?:\s|$)/,
+        /^tail(?:\s|$)/,
+        /^wc(?:\s|$)/,
+        /^sort(?:\s|$)/,
+        /^uniq(?:\s|$)/,
+        /^find(?:\s|$)/,
+        /^grep(?:\s|$)/,
+        /^rg(?:\s|$)/,
+        /^git status(?:\s|$)/,
+        /^git diff(?:\s|$)/,
+        /^git log(?:\s|$)/,
+    ];
+    return safePatterns.some((pattern) => pattern.test(normalized));
+}
+export function normalizeCodexAppServerInteractionRequest(message) {
+    const method = typeof message.method === 'string' ? message.method : '';
+    const params = (typeof message.params === 'object' && message.params !== null
+        ? message.params
+        : {});
+    const approvalMetadata = extractAutoModeApprovalMetadata(message, params);
+    if (method === 'item/commandExecution/requestApproval') {
+        const command = typeof params.command === 'string' ? params.command : undefined;
+        const cwd = typeof params.cwd === 'string' ? params.cwd : undefined;
+        return {
+            kind: 'command-approval',
+            message: command || 'Codex requests command approval',
+            command,
+            cwd,
+            ...approvalMetadata,
+            raw: message,
+        };
+    }
+    if (method === 'item/fileChange/requestApproval') {
+        const reason = typeof params.reason === 'string' ? params.reason : undefined;
+        return {
+            kind: 'file-change-approval',
+            message: reason && reason.trim() ? reason : 'Codex requests file-change approval',
+            ...(reason ? { reason } : {}),
+            ...approvalMetadata,
+            raw: message,
+        };
+    }
+    if (method === 'item/permissions/requestApproval') {
+        const reason = typeof params.reason === 'string' ? params.reason : undefined;
+        const permissions = isRecord(params.permissions) ? params.permissions : {};
+        return {
+            kind: 'permissions-approval',
+            message: reason && reason.trim() ? reason : 'Codex requests additional permissions',
+            permissions,
+            ...approvalMetadata,
+            raw: message,
+        };
+    }
+    if (method === 'item/tool/requestUserInput') {
+        const questions = Array.isArray(params.questions)
+            ? params.questions
+                .map((question, index) => normalizeAutoModeUserInputQuestion(question, `question-${index + 1}`))
+                .filter((question) => question !== null)
+            : [];
+        return {
+            kind: 'user-input',
+            message: 'Codex requests structured user input',
+            questions,
+            raw: message,
+        };
+    }
+    if (method === 'applyPatchApproval' || method === 'execCommandApproval') {
+        return {
+            kind: 'codex-approval',
+            message: 'Codex requests approval',
+            ...approvalMetadata,
+            raw: message,
+        };
+    }
+    return null;
+}
+export function resolveAutoModeInteractionAutoResponse(input) {
+    const { mode, request } = input;
+    if (request.kind === 'user-input' || request.kind === 'codex-approval') {
+        return null;
+    }
+    const decision = resolveAutoModeAutoApprovalDecision({
+        mode,
+        request,
+    });
+    if (!decision) {
+        return null;
+    }
+    return buildCodexApprovalResponse(request, decision);
+}
+export function buildCodexApprovalResponse(request, decision) {
+    if (request.kind === 'permissions-approval') {
+        if (decision === 'accept') {
+            return { permissions: request.permissions, scope: 'turn' };
+        }
+        if (decision === 'accept_for_session') {
+            return { permissions: request.permissions, scope: 'session' };
+        }
+        return { permissions: {}, scope: 'turn' };
+    }
+    if (request.kind === 'codex-approval') {
+        if (decision === 'accept') {
+            return { decision: 'approved' };
+        }
+        if (decision === 'accept_for_session') {
+            return { decision: 'approved_for_session' };
+        }
+        if (decision === 'cancel') {
+            return { decision: 'abort' };
+        }
+        return { decision: 'denied' };
+    }
+    if (decision === 'accept') {
+        return { decision: 'accept' };
+    }
+    if (decision === 'accept_for_session') {
+        return { decision: 'acceptForSession' };
+    }
+    if (decision === 'cancel') {
+        return { decision: 'cancel' };
+    }
+    return { decision: 'decline' };
+}
+export function buildCodexUserInputResponse(answers) {
+    return { answers };
+}
+export function buildAutoModeUserInputResponse(answers) {
+    return buildCodexUserInputResponse(answers);
+}
+export function normalizeAcpInteractionRequest(message) {
+    const method = typeof message.method === 'string' ? message.method.toLowerCase() : '';
+    const params = (recordFromUnknown(message.params) ?? {});
+    if (method === 'session/request_permission' || Array.isArray(params.options)) {
+        const approvalMetadata = extractAutoModeApprovalMetadata(message, params);
+        const toolCall = (recordFromUnknown(params.toolCall) ?? {});
+        const toolKind = typeof toolCall.kind === 'string' ? toolCall.kind : '';
+        const command = extractAcpCommand(toolCall.rawInput);
+        const cwd = firstNonEmpty([
+            typeof toolCall.cwd === 'string' ? toolCall.cwd : undefined,
+            recordFromUnknown(toolCall.rawInput) && typeof recordFromUnknown(toolCall.rawInput)?.cwd === 'string'
+                ? recordFromUnknown(toolCall.rawInput)?.cwd
+                : undefined,
+        ]);
+        const messageText = firstNonEmpty([
+            typeof toolCall.title === 'string' ? toolCall.title : undefined,
+            command,
+            extractAutoModeJsonText(toolCall),
+            method || undefined,
+        ]) ?? 'Approval required';
+        if (toolKind === 'execute' || command) {
+            return {
+                kind: 'command-approval',
+                message: command ?? messageText,
+                ...(command ? { command } : {}),
+                ...(cwd ? { cwd } : {}),
+                ...approvalMetadata,
+                raw: message,
+            };
+        }
+        if (toolKind === 'edit' || toolKind === 'delete' || toolKind === 'move') {
+            return {
+                kind: 'file-change-approval',
+                message: messageText,
+                reason: messageText,
+                ...approvalMetadata,
+                raw: message,
+            };
+        }
+        return {
+            kind: 'permissions-approval',
+            message: messageText,
+            permissions: recordFromUnknown(toolCall.rawInput) ?? {},
+            ...approvalMetadata,
+            raw: message,
+        };
+    }
+    const looksLikeInput = method.includes('request_input')
+        || method.includes('requestuserinput')
+        || method.includes('user_input')
+        || Array.isArray(params.questions);
+    if (!looksLikeInput) {
+        return null;
+    }
+    const questions = Array.isArray(params.questions)
+        ? params.questions
+            .map((question, index) => normalizeAutoModeUserInputQuestion(question, `question-${index + 1}`))
+            .filter((question) => question !== null)
+        : [];
+    return {
+        kind: 'user-input',
+        message: firstNonEmpty([
+            extractAutoModeJsonText(params.message),
+            extractAutoModeJsonText(params.prompt),
+            extractAutoModeJsonText(params.question),
+            questions[0]?.question,
+        ]) ?? 'Input required',
+        questions,
+        raw: message,
+    };
+}
+export function normalizeAcpRequest(message) {
+    const interaction = normalizeAcpInteractionRequest(message);
+    if (!interaction) {
+        return [];
+    }
+    if (interaction.kind === 'user-input') {
+        return [{
+                type: 'input.required',
+                message: interaction.message,
+                request: interaction,
+                raw: message,
+            }];
+    }
+    const events = [{
+            type: 'approval.required',
+            message: interaction.message,
+            request: interaction,
+            raw: message,
+        }];
+    if (interaction.kind === 'command-approval' && interaction.command) {
+        events.push({
+            type: 'tool.call',
+            name: 'commandExecution',
+            arguments: {
+                command: interaction.command,
+                cwd: interaction.cwd,
+            },
+            raw: message,
+        });
+    }
+    return events;
+}
+function normalizeAcpToolCallEvent(update, raw) {
+    const name = firstNonEmpty([
+        typeof update.title === 'string' ? update.title : undefined,
+        typeof update.kind === 'string' ? update.kind : undefined,
+        typeof update.toolCallId === 'string' ? update.toolCallId : undefined,
+    ]);
+    if (!name) {
+        return null;
+    }
+    const args = extractAutoModeJsonArguments(update.rawInput);
+    return {
+        type: 'tool.call',
+        name,
+        ...(args ? { arguments: args } : {}),
+        raw,
+    };
+}
+export function normalizeAcpSessionNotification(message) {
+    const method = typeof message.method === 'string' ? message.method : '';
+    const params = (recordFromUnknown(message.params) ?? {});
+    if (method !== 'session/update') {
+        return [];
+    }
+    const update = (recordFromUnknown(params.update) ?? {});
+    const updateType = firstNonEmpty([
+        typeof update.sessionUpdate === 'string' ? update.sessionUpdate : undefined,
+        typeof update.type === 'string' ? update.type : undefined,
+    ])?.toLowerCase() ?? '';
+    if (updateType === 'available_commands_update' || updateType === 'usage_update') {
+        return [];
+    }
+    if (updateType === 'agent_message_chunk') {
+        const text = extractAutoModeJsonText(update.content ?? update);
+        return text ? [{ type: 'assistant.delta', text, raw: message }] : [];
+    }
+    if (updateType === 'agent_thought_chunk') {
+        return [];
+    }
+    if (updateType === 'tool_call' || updateType === 'tool_call_update') {
+        const toolEvent = normalizeAcpToolCallEvent(update, message);
+        if (toolEvent) {
+            return [toolEvent];
+        }
+    }
+    const text = extractAutoModeJsonText(update);
+    if (!text) {
+        return [];
+    }
+    return [{
+            type: 'session.note',
+            message: text,
+            raw: message,
+        }];
+}
+export function buildAcpPermissionResponse(request, decision) {
+    if (decision === 'cancel') {
+        return {
+            outcome: { outcome: 'cancelled' },
+        };
+    }
+    const raw = recordFromUnknown(request.raw);
+    const params = recordFromUnknown(raw?.params) ?? {};
+    const optionId = selectAcpPermissionOption(normalizeAcpPermissionOptions(params.options), decision);
+    if (!optionId) {
+        return {
+            outcome: { outcome: 'cancelled' },
+        };
+    }
+    return {
+        outcome: {
+            outcome: 'selected',
+            optionId,
+        },
+    };
+}
+function maybeAutoModeToolEvent(json, lowerType) {
+    const toolName = firstNonEmpty([
+        typeof json.toolName === 'string' ? json.toolName : undefined,
+        typeof json.name === 'string' ? json.name : undefined,
+        typeof json.tool === 'string' ? json.tool : undefined,
+        isRecord(json.tool) && typeof json.tool.name === 'string' ? json.tool.name : undefined,
+        typeof json.command === 'string' ? json.command : undefined,
+    ]);
+    const looksLikeTool = lowerType.includes('tool')
+        || lowerType.includes('command')
+        || lowerType.includes('function_call')
+        || (toolName !== undefined && !lowerType.includes('approval'));
+    if (!looksLikeTool || !toolName) {
+        return null;
+    }
+    return {
+        type: 'tool.call',
+        name: toolName,
+        arguments: extractAutoModeJsonArguments(json.arguments ?? json.args ?? json.input),
+        raw: json,
+    };
+}
+function maybeAutoModeInputEvent(json, lowerType) {
+    const looksLikeInput = lowerType.includes('request_user_input')
+        || lowerType.includes('user_input')
+        || Array.isArray(json.questions);
+    if (!looksLikeInput) {
+        return null;
+    }
+    const questions = Array.isArray(json.questions)
+        ? json.questions
+            .map((question, index) => normalizeAutoModeUserInputQuestion(question, `question-${index + 1}`))
+            .filter((question) => question !== null)
+        : [];
+    const message = firstNonEmpty([
+        extractAutoModeJsonText(json.message),
+        extractAutoModeJsonText(json.prompt),
+        extractAutoModeJsonText(json.question),
+        extractAutoModeJsonText(json.description),
+    ]) || 'Input required';
+    const request = {
+        kind: 'user-input',
+        message,
+        questions,
+        raw: json,
+    };
+    return {
+        type: 'input.required',
+        message,
+        request,
+        raw: json,
+    };
+}
+function maybeAutoModeApprovalEvent(json, lowerType) {
+    const looksLikeApproval = lowerType.includes('approval')
+        || lowerType.includes('permission')
+        || isRecord(json.permissions);
+    if (!looksLikeApproval) {
+        return null;
+    }
+    const message = firstNonEmpty([
+        extractAutoModeJsonText(json.message),
+        extractAutoModeJsonText(json.reason),
+        extractAutoModeJsonText(json.prompt),
+        extractAutoModeJsonText(json.question),
+        extractAutoModeJsonText(json.description),
+        lowerType || undefined,
+    ]);
+    return {
+        type: 'approval.required',
+        message: message || 'Approval required',
+        ...(isRecord(json.permissions)
+            ? {
+                request: {
+                    kind: 'permissions-approval',
+                    message: message || 'Approval required',
+                    permissions: json.permissions,
+                    ...extractAutoModeApprovalMetadata(json, json),
+                    raw: json,
+                },
+            }
+            : {}),
+        raw: json,
+    };
+}
+function maybeAutoModeAssistantDoneEvent(json, lowerType) {
+    const isDone = lowerType.includes('done')
+        || lowerType.includes('completed')
+        || lowerType === 'result'
+        || lowerType.endsWith('.result')
+        || lowerType.endsWith('.done');
+    if (!isDone) {
+        return null;
+    }
+    return {
+        type: 'assistant.done',
+        text: extractAutoModeJsonText(json),
+        raw: json,
+    };
+}
+function maybeAutoModeAssistantDeltaEvent(json, lowerType) {
+    const isDelta = lowerType.includes('delta')
+        || lowerType.includes('assistant')
+        || lowerType.includes('message')
+        || lowerType.includes('content_block')
+        || lowerType.includes('text');
+    if (!isDelta) {
+        return null;
+    }
+    const text = firstNonEmpty([
+        extractAutoModeJsonText(json.delta),
+        extractAutoModeJsonText(json.text),
+        extractAutoModeJsonText(json.message),
+        extractAutoModeJsonText(json.content),
+    ]);
+    if (!text) {
+        return null;
+    }
+    return {
+        type: 'assistant.delta',
+        text,
+        raw: json,
+    };
+}
+export function parseAutoModeJsonProtocolLine(line) {
+    const json = parseAutoModeJsonLine(line);
+    if (!json) {
+        return [];
+    }
+    const lowerType = typeof json.type === 'string' ? json.type.toLowerCase() : '';
+    const events = [];
+    const inputEvent = maybeAutoModeInputEvent(json, lowerType);
+    if (inputEvent) {
+        events.push(inputEvent);
+    }
+    const approvalEvent = maybeAutoModeApprovalEvent(json, lowerType);
+    if (approvalEvent) {
+        events.push(approvalEvent);
+    }
+    const toolEvent = maybeAutoModeToolEvent(json, lowerType);
+    if (toolEvent) {
+        events.push(toolEvent);
+    }
+    const doneEvent = maybeAutoModeAssistantDoneEvent(json, lowerType);
+    if (doneEvent) {
+        events.push(doneEvent);
+    }
+    else {
+        const deltaEvent = maybeAutoModeAssistantDeltaEvent(json, lowerType);
+        if (deltaEvent) {
+            events.push(deltaEvent);
+        }
+    }
+    if (events.length === 0) {
+        const text = extractAutoModeJsonText(json);
+        if (text) {
+            events.push({
+                type: 'session.note',
+                message: text,
+                raw: json,
+            });
+        }
+    }
+    return events;
+}
+function normalizeCodexThreadItem(item, raw) {
+    const type = typeof item.type === 'string' ? item.type : '';
+    if (type === 'userMessage') {
+        const content = Array.isArray(item.content)
+            ? item.content
+                .map((part) => (typeof part === 'object' && part !== null ? part : null))
+                .filter((part) => part !== null)
+                .map((part) => (typeof part.text === 'string' ? part.text : ''))
+                .filter((text) => text.length > 0)
+                .join('')
+            : '';
+        return content
+            ? [{
+                    type: 'session.note',
+                    message: `userMessage · ${content}`,
+                    raw,
+                }]
+            : [];
+    }
+    if (type === 'commandExecution') {
+        return [{
+                type: 'tool.call',
+                name: 'commandExecution',
+                arguments: {
+                    command: item.command,
+                    cwd: item.cwd,
+                    status: item.status,
+                },
+                raw,
+            }];
+    }
+    if (type === 'fileChange') {
+        return [{
+                type: 'tool.call',
+                name: 'fileChange',
+                arguments: {
+                    status: item.status,
+                },
+                raw,
+            }];
+    }
+    if (type === 'mcpToolCall' || type === 'dynamicToolCall') {
+        return [{
+                type: 'tool.call',
+                name: typeof item.tool === 'string' ? item.tool : type,
+                arguments: (typeof item.arguments === 'object' && item.arguments !== null ? item.arguments : undefined),
+                raw,
+            }];
+    }
+    return [];
+}
+export function normalizeCodexAppServerNotification(message) {
+    const method = typeof message.method === 'string' ? message.method : '';
+    const params = (typeof message.params === 'object' && message.params !== null
+        ? message.params
+        : {});
+    if (method === 'thread/started') {
+        return [{
+                type: 'session.note',
+                message: 'Thread started',
+                raw: message,
+            }];
+    }
+    if (method === 'thread/status/changed') {
+        const status = (typeof params.status === 'object' && params.status !== null ? params.status : {});
+        const statusType = typeof status.type === 'string' ? status.type : 'unknown';
+        return [{
+                type: 'session.note',
+                message: `Thread status · ${statusType}`,
+                raw: message,
+            }];
+    }
+    if (method === 'turn/started') {
+        return [{
+                type: 'session.note',
+                message: 'Turn started',
+                raw: message,
+            }];
+    }
+    if (method === 'item/agentMessage/delta' && typeof params.delta === 'string') {
+        return [{ type: 'assistant.delta', text: params.delta, raw: message }];
+    }
+    if (method === 'turn/completed') {
+        return [{ type: 'assistant.done', raw: message }];
+    }
+    if ((method === 'item/commandExecution/outputDelta' || method === 'item/reasoning/textDelta' || method === 'item/reasoning/summaryTextDelta')
+        && typeof params.delta === 'string') {
+        return [{ type: 'session.note', message: params.delta, raw: message }];
+    }
+    if (method === 'item/started' || method === 'item/completed') {
+        const item = (typeof params.item === 'object' && params.item !== null ? params.item : {});
+        return normalizeCodexThreadItem(item, message);
+    }
+    if (method === 'error') {
+        return [{
+                type: 'session.note',
+                message: extractAutoModeJsonText(params.error) || 'Codex error',
+                raw: message,
+            }];
+    }
+    return [];
+}
+export function normalizeCodexAppServerRequest(message) {
+    const method = typeof message.method === 'string' ? message.method : '';
+    const params = (typeof message.params === 'object' && message.params !== null
+        ? message.params
+        : {});
+    const interaction = normalizeCodexAppServerInteractionRequest(message);
+    if (interaction?.kind === 'user-input') {
+        return [{
+                type: 'input.required',
+                message: interaction.message,
+                request: interaction,
+                raw: message,
+            }];
+    }
+    if (interaction) {
+        const events = [{
+                type: 'approval.required',
+                message: interaction.message,
+                request: interaction,
+                raw: message,
+            }];
+        if (interaction.kind === 'command-approval' && interaction.command) {
+            events.push({
+                type: 'tool.call',
+                name: 'commandExecution',
+                arguments: {
+                    command: interaction.command,
+                    cwd: interaction.cwd,
+                },
+                raw: message,
+            });
+        }
+        return events;
+    }
+    if (method === 'item/tool/call') {
+        return [{
+                type: 'tool.call',
+                name: typeof params.tool === 'string' ? params.tool : 'dynamicToolCall',
+                arguments: (typeof params.arguments === 'object' && params.arguments !== null ? params.arguments : undefined),
+                raw: message,
+            }];
+    }
+    return [];
+}
+export function getAutoModeArchiveRelativePaths(sessionId) {
+    const normalizedId = sessionId.trim();
+    const sessionDir = `${AUTO_MODE_SESSIONS_DIRNAME}/${normalizedId}`;
+    return {
+        sessionDir,
+        sessionFile: `${sessionDir}/${AUTO_MODE_SESSION_FILE_NAME}`,
+        eventsFile: `${sessionDir}/${AUTO_MODE_EVENTS_FILE_NAME}`,
+    };
+}
+export function buildAutoModeThreadMetadata(record) {
+    return {
+        kind: 'auto-mode',
+        delegatedTo: 'secretary',
+        sessionId: record.id,
+        backend: record.backend,
+        runtime: record.runtime,
+        transport: record.transport,
+        mode: record.mode,
+        cwd: record.cwd,
+        model: record.model,
+        credentialSource: record.credentialSource,
+        resolvedCredentialSource: record.resolvedCredentialSource,
+        approvalSource: record.approvalSource,
+        status: record.status,
+        backendSessionId: record.backendSessionId,
+    };
+}
+function pushAutoModeTranscriptMessage(messages, role, source, content, createdAt) {
+    const normalized = content?.replace(/\r/g, '').trimEnd();
+    if (!normalized) {
+        return;
+    }
+    messages.push({
+        role,
+        source,
+        content: normalized,
+        createdAt,
+    });
+}
+function flushAutoModeAssistantMessage(messages, state, fallbackTimestamp) {
+    if (!state.assistantText.trim()) {
+        state.assistantText = '';
+        state.assistantTimestamp = undefined;
+        return;
+    }
+    pushAutoModeTranscriptMessage(messages, 'assistant', 'primary-agent', state.assistantText, state.assistantTimestamp ?? fallbackTimestamp);
+    state.assistantText = '';
+    state.assistantTimestamp = undefined;
+}
+function appendAutoModeTranscriptEvent(messages, state, entry, event) {
+    if (event.type === 'assistant.delta') {
+        if (!state.assistantTimestamp) {
+            state.assistantTimestamp = entry.timestamp;
+        }
+        state.assistantText += event.text;
+        return;
+    }
+    if (event.type === 'assistant.done') {
+        if (event.text && !state.assistantText) {
+            pushAutoModeTranscriptMessage(messages, 'assistant', 'primary-agent', event.text, entry.timestamp);
+            return;
+        }
+        flushAutoModeAssistantMessage(messages, state, entry.timestamp);
+        return;
+    }
+    flushAutoModeAssistantMessage(messages, state, entry.timestamp);
+    if (event.type === 'tool.call') {
+        pushAutoModeTranscriptMessage(messages, 'system', 'tool', `[tool] ${event.name}${event.arguments ? ` ${JSON.stringify(event.arguments)}` : ''}`, entry.timestamp);
+        return;
+    }
+    if (event.type === 'approval.required') {
+        pushAutoModeTranscriptMessage(messages, 'system', 'secretary', `[approval] ${event.message}`, entry.timestamp);
+        return;
+    }
+    if (event.type === 'input.required') {
+        pushAutoModeTranscriptMessage(messages, 'system', 'secretary', `[input] ${event.message}`, entry.timestamp);
+        return;
+    }
+    pushAutoModeTranscriptMessage(messages, 'system', 'system', `[note] ${event.message}`, entry.timestamp);
+}
+function appendAutoModeTranscriptRawEntry(messages, entry) {
+    const trimmed = entry.line.trim();
+    if (!trimmed) {
+        return;
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        const type = typeof parsed.type === 'string' ? parsed.type : '';
+        if (type === 'user.turn' && typeof parsed.text === 'string') {
+            pushAutoModeTranscriptMessage(messages, 'user', 'user', parsed.text, entry.timestamp);
+            return;
+        }
+        if (type === 'turn.start') {
+            const command = typeof parsed.command === 'string' ? parsed.command : 'unknown';
+            const args = Array.isArray(parsed.args)
+                ? parsed.args.filter((value) => typeof value === 'string')
+                : [];
+            pushAutoModeTranscriptMessage(messages, 'system', 'system', `[turn] ${[command, ...args].join(' ').trim()}`, entry.timestamp);
+            return;
+        }
+        if (type === 'credentials.resolve') {
+            const requested = typeof parsed.requestedCredentialSource === 'string' ? parsed.requestedCredentialSource : 'auto';
+            const resolved = typeof parsed.resolvedCredentialSource === 'string' ? parsed.resolvedCredentialSource : requested;
+            pushAutoModeTranscriptMessage(messages, 'system', 'system', `[credentials] ${requested} -> ${resolved}`, entry.timestamp);
+            return;
+        }
+        if (type === 'process.error' && typeof parsed.message === 'string') {
+            pushAutoModeTranscriptMessage(messages, 'system', 'system', `[error] ${parsed.message}`, entry.timestamp);
+            return;
+        }
+    }
+    catch {
+        // Keep original line when it is not structured JSON.
+    }
+    pushAutoModeTranscriptMessage(messages, 'system', entry.stream === 'stderr' ? 'system' : 'primary-agent', entry.stream === 'stderr' ? `stderr> ${trimmed}` : trimmed, entry.timestamp);
+}
+export function buildAutoModeTranscriptMessages(entries) {
+    const messages = [];
+    const state = {
+        assistantText: '',
+    };
+    for (const entry of entries) {
+        if (entry.events.length > 0) {
+            for (const event of entry.events) {
+                appendAutoModeTranscriptEvent(messages, state, entry, event);
+            }
+            continue;
+        }
+        flushAutoModeAssistantMessage(messages, state, entry.timestamp);
+        appendAutoModeTranscriptRawEntry(messages, entry);
+    }
+    flushAutoModeAssistantMessage(messages, state, new Date().toISOString());
+    return messages;
+}