@praxis-ai/praxis 0.1.0 → 0.1.1

package/raxode-tui/dist/raxode-cli/backend/directApplicationBackend.js

@@ -0,0 +1,1211 @@
+/*
+ * 文件定位：raxode-cli/backend direct TUI adapter。
+ * 核心目的：让 direct TUI 的现有 UI/输入协议接入新的 applicationLayer Raxode 后端。
+ */
+import { mkdir, appendFile } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { inspectRaxodeMemoryBridge } from "./memory/memoryBridge.js";
+import { loadDirectTuiSessionSnapshot, listDirectTuiAgents, saveDirectTuiAgent, saveDirectTuiSessionSnapshot, } from "../frontend/tui/input/direct-session-store.js";
+function defaultProjectRoot() {
+    return new URL(".", import.meta.url).pathname;
+}
+function defaultStateRoot(cwd) {
+    return path.resolve(process.env.PRAXIS_STATE_ROOT ?? process.env.RAXODE_HOME ?? path.join(cwd, ".raxode"));
+}
+function normalizePermissionProfile(value) {
+    switch (value) {
+        case "bapr":
+        case "yolo":
+        case "permissive":
+        case "standard":
+        case "restricted":
+            return value;
+        case "balanced":
+            return "permissive";
+        case "strict":
+            return "standard";
+        default:
+            return "standard";
+    }
+}
+function normalizeInitialTurnIndex(value) {
+    const parsed = typeof value === "number"
+        ? value
+        : typeof value === "string"
+            ? Number.parseInt(value, 10)
+            : 0;
+    return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : 0;
+}
+function parsePositiveIntegerEnv(value) {
+    if (value === undefined)
+        return undefined;
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
+function parsePositiveRatioEnv(value) {
+    if (value === undefined)
+        return undefined;
+    const parsed = Number.parseFloat(value);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
+function resolveDirectCompactOptions(options) {
+    const exactLimit = parsePositiveIntegerEnv(process.env.PRAXIS_COMPACT_LIMIT_TOKENS ?? process.env.RAXODE_COMPACT_LIMIT_TOKENS);
+    if (exactLimit !== undefined) {
+        return {
+            compactContextWindowTokens: exactLimit,
+            compactThresholdRatio: 1,
+        };
+    }
+    return {
+        compactContextWindowTokens: options.compactContextWindowTokens ?? parsePositiveIntegerEnv(process.env.PRAXIS_COMPACT_CONTEXT_WINDOW_TOKENS ?? process.env.RAXODE_COMPACT_CONTEXT_WINDOW_TOKENS),
+        compactThresholdRatio: options.compactThresholdRatio ?? parsePositiveRatioEnv(process.env.PRAXIS_COMPACT_THRESHOLD_RATIO ?? process.env.RAXODE_COMPACT_THRESHOLD_RATIO),
+    };
+}
+function resolveDirectApplicationMode(explicitMode) {
+    if (explicitMode)
+        return explicitMode;
+    return (process.env.RAXODE_DIRECT_APPLICATION_MODE ?? process.env.RAXODE_LEGACY_APPLICATION_MODE) === "dry-run"
+        ? "dry-run"
+        : "live";
+}
+function normalizeDirectPayload(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed.startsWith("{")) {
+        return { text: raw, inputSource: "manual", attachments: [] };
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (parsed.type === "direct_question_answer") {
+            const text = (parsed.answers ?? [])
+                .map((answer) => {
+                const questionId = typeof answer.questionId === "string" ? answer.questionId : "question";
+                const value = typeof answer.answerText === "string"
+                    ? answer.answerText
+                    : typeof answer.selectedOptionLabel === "string"
+                        ? answer.selectedOptionLabel
+                        : typeof answer.selectedOptionId === "string"
+                            ? answer.selectedOptionId
+                            : "";
+                return `${questionId}: ${value}`;
+            })
+                .filter((line) => line.trim().length > 0)
+                .join("\n");
+            return {
+                text: text || "Question answers submitted.",
+                inputSource: "question_answer",
+                attachments: [],
+            };
+        }
+        if (parsed.type !== "direct_user_input" && parsed.type !== "direct_init_request") {
+            return { text: raw, inputSource: "manual", attachments: [] };
+        }
+        const pastedAttachments = (parsed.pastedContents ?? []).flatMap((entry, index) => {
+            const text = typeof entry.text === "string" ? entry.text : "";
+            if (!text)
+                return [];
+            const tokenText = typeof entry.tokenText === "string" ? entry.tokenText : `[Pasted Content #${index + 1}]`;
+            return [{
+                    id: typeof entry.id === "string" ? entry.id : `direct-paste:${index + 1}`,
+                    kind: "text",
+                    tokenText,
+                    displayName: tokenText,
+                    text,
+                    metadata: {
+                        sourceKind: "direct-tui",
+                    },
+                }];
+        });
+        const fileAttachments = (parsed.fileRefs ?? []).flatMap((entry, index) => {
+            const localPath = typeof entry.absolutePath === "string" ? entry.absolutePath : "";
+            if (!localPath)
+                return [];
+            return [{
+                    id: typeof entry.id === "string" ? entry.id : `direct-file:${index + 1}`,
+                    kind: "file",
+                    tokenText: typeof entry.tokenText === "string" ? entry.tokenText : `@${localPath}`,
+                    displayName: typeof entry.displayName === "string" ? entry.displayName : path.basename(localPath),
+                    localPath,
+                    metadata: {
+                        sourceKind: "direct-tui",
+                    },
+                }];
+        });
+        const imageAttachments = (parsed.attachments ?? []).flatMap((entry, index) => {
+            const localPath = typeof entry.localPath === "string" ? entry.localPath : undefined;
+            const remoteUrl = typeof entry.remoteUrl === "string" ? entry.remoteUrl : undefined;
+            if (!localPath && !remoteUrl)
+                return [];
+            return [{
+                    id: typeof entry.id === "string" ? entry.id : `direct-attachment:${index + 1}`,
+                    kind: "image",
+                    tokenText: typeof entry.tokenText === "string" ? entry.tokenText : `[Image #${index + 1}]`,
+                    displayName: typeof entry.displayName === "string" ? entry.displayName : undefined,
+                    mimeType: typeof entry.mimeType === "string" ? entry.mimeType : undefined,
+                    localPath,
+                    remoteUrl,
+                    metadata: {
+                        sourceKind: "direct-tui",
+                    },
+                }];
+        });
+        return {
+            text: parsed.text ?? "",
+            inputSource: parsed.type === "direct_init_request" ? "init" : "manual",
+            attachments: [...imageAttachments, ...pastedAttachments, ...fileAttachments],
+        };
+    }
+    catch {
+        return { text: raw, inputSource: "manual", attachments: [] };
+    }
+}
+function parseDirectHumanGateDecision(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed.startsWith("{"))
+        return undefined;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (parsed.type !== "human_gate_decision")
+            return undefined;
+        const gateId = typeof parsed.gateId === "string" ? parsed.gateId.trim() : "";
+        const action = parsed.action;
+        if (gateId.length === 0
+            || (action !== "approve" && action !== "approve_always" && action !== "reject" && action !== "reject_stop")) {
+            return undefined;
+        }
+        return {
+            type: "human_gate_decision",
+            gateId,
+            action,
+            note: typeof parsed.note === "string" && parsed.note.trim().length > 0 ? parsed.note.trim() : undefined,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+function runtimeApprovalToolId(envelope) {
+    const toolId = envelope.metadata.toolId;
+    return typeof toolId === "string" && toolId.trim().length > 0 ? toolId.trim() : undefined;
+}
+function inferRuntimeApprovalFeature(envelope) {
+    const toolId = runtimeApprovalToolId(envelope);
+    if (toolId?.startsWith("computer.") || toolId?.startsWith("computeruse.")) {
+        return { featureKey: "computer_use", featureDisplay: "computer_use", toolId };
+    }
+    if (toolId) {
+        const family = toolId.split(".")[0] ?? "tool";
+        return { featureKey: family, featureDisplay: family, toolId };
+    }
+    if (envelope.source === "model") {
+        return { featureKey: "model_approval", featureDisplay: "model_approval" };
+    }
+    if (envelope.source === "runtime") {
+        return { featureKey: "runtime", featureDisplay: "runtime" };
+    }
+    return { featureKey: "tool", featureDisplay: "tool" };
+}
+function normalizeApprovalRiskLevel(riskLevel) {
+    if (riskLevel === "dangerous")
+        return "dangerous";
+    if (riskLevel === "safe" || riskLevel === "normal")
+        return "normal";
+    return "risky";
+}
+function runtimeApprovalSummary(featureDisplay) {
+    return `Raxode now infers: Under the current circumstances, the "${featureDisplay}" feature should be used.`;
+}
+function buildRuntimeApprovalPanelSnapshot(pendingApprovals, now) {
+    const pendingHumanGates = [...pendingApprovals.values()].map((pending) => {
+        const updatedAt = now();
+        const riskLevel = normalizeApprovalRiskLevel(pending.envelope.riskLevel);
+        return {
+            gateId: pending.envelope.approvalId,
+            requestId: pending.envelope.approvalId,
+            capabilityKey: pending.featureDisplay,
+            requestedTier: riskLevel,
+            mode: "application-approval",
+            reason: pending.envelope.reason,
+            createdAt: updatedAt,
+            updatedAt,
+            externalPathPrefixes: [],
+            plainLanguageRisk: {
+                plainLanguageSummary: runtimeApprovalSummary(pending.featureDisplay),
+                requestedAction: pending.toolId ? `Use ${pending.toolId}` : `Use ${pending.featureDisplay}`,
+                riskLevel,
+                whyItIsRisky: pending.envelope.reason,
+                possibleConsequence: `The ${pending.featureDisplay} feature may interact with runtime resources or the desktop session.`,
+                whatHappensIfNotRun: `Raxode will continue without using ${pending.featureDisplay} for this request.`,
+                availableUserActions: [
+                    {
+                        actionId: "approve-once",
+                        label: "Approve the use of this feature this time.",
+                        kind: "approve",
+                    },
+                    {
+                        actionId: "approve-always",
+                        label: "Always Approve this feature for this session.",
+                        kind: "approve",
+                    },
+                    {
+                        actionId: "continue-deny",
+                        label: "Continue and Deny the use of this feature this time.",
+                        kind: "deny",
+                    },
+                    {
+                        actionId: "stop-deny",
+                        label: "Stop and Deny the use of this feature this time.",
+                        kind: "deny",
+                    },
+                ],
+                metadata: {
+                    sourceKind: "application-approval",
+                    approvalId: pending.envelope.approvalId,
+                    featureKey: pending.featureKey,
+                    featureDisplay: pending.featureDisplay,
+                    ...(pending.toolId ? { toolId: pending.toolId } : {}),
+                },
+            },
+        };
+    });
+    return {
+        summaryLines: pendingHumanGates.length > 0
+            ? [`${pendingHumanGates.length} approval request(s) waiting for human decision.`]
+            : ["No pending application approval requests."],
+        status: pendingHumanGates.length > 0 ? "waiting_human" : "ready",
+        registeredCount: 0,
+        familyCount: 0,
+        blockedCount: 0,
+        pendingHumanGateCount: pendingHumanGates.length,
+        pendingHumanGates,
+        groups: [],
+    };
+}
+function approvalDecisionToRuntimeResolution(input) {
+    if (input.decision.action === "approve" || input.decision.action === "approve_always") {
+        return {
+            status: "approved",
+            resolvedBy: input.decision.action === "approve_always"
+                ? "raxode.tui.approve_always"
+                : "raxode.tui.approve_once",
+            reason: input.decision.note ?? `${input.pending.featureDisplay} approved by human through Raxode TUI`,
+            metadata: {
+                approvalId: input.pending.envelope.approvalId,
+                featureKey: input.pending.featureKey,
+                featureDisplay: input.pending.featureDisplay,
+                decision: input.decision.action,
+            },
+        };
+    }
+    return {
+        status: "denied",
+        resolvedBy: input.decision.action === "reject_stop"
+            ? "raxode.tui.reject_stop"
+            : "raxode.tui.reject",
+        reason: input.decision.note ?? `${input.pending.featureDisplay} denied by human through Raxode TUI`,
+        metadata: {
+            approvalId: input.pending.envelope.approvalId,
+            featureKey: input.pending.featureKey,
+            featureDisplay: input.pending.featureDisplay,
+            decision: input.decision.action,
+            stopTurn: input.decision.action === "reject_stop",
+        },
+    };
+}
+async function writeLog(logPath, record) {
+    await appendFile(logPath, `${JSON.stringify(record)}\n`, "utf8");
+}
+function hasUsageNumber(usage) {
+    return usage !== undefined && (typeof usage.inputTokens === "number" ||
+        typeof usage.outputTokens === "number" ||
+        typeof usage.thinkingTokens === "number" ||
+        typeof usage.totalTokens === "number" ||
+        typeof usage.cachedInputTokens === "number");
+}
+function hasContextNumber(context) {
+    return context !== undefined && (typeof context.activeTokens === "number" ||
+        typeof context.promptTokens === "number" ||
+        typeof context.transcriptTokens === "number");
+}
+function buildContextSnapshot(result) {
+    const model = result?.view.model;
+    const context = hasContextNumber(result?.view.context) ? result.view.context : undefined;
+    const usage = hasUsageNumber(result?.view.usage) ? result.view.usage : undefined;
+    const observedInputTokens = typeof usage?.lastInputTokens === "number" && Number.isFinite(usage.lastInputTokens)
+        ? usage.lastInputTokens
+        : typeof usage?.inputTokens === "number" && Number.isFinite(usage.inputTokens)
+            ? usage.inputTokens
+            : undefined;
+    const observedTotalTokens = typeof usage?.lastTotalTokens === "number" && Number.isFinite(usage.lastTotalTokens)
+        ? usage.lastTotalTokens
+        : typeof usage?.totalTokens === "number" && Number.isFinite(usage.totalTokens)
+            ? usage.totalTokens
+            : undefined;
+    const estimatedActiveTokens = context?.activeTokens ?? context?.promptTokens ?? 0;
+    const activeTokens = observedInputTokens ?? estimatedActiveTokens;
+    const sessionContextTokens = typeof context?.sessionContextTokens === "number" && Number.isFinite(context.sessionContextTokens)
+        ? context.sessionContextTokens
+        : context?.historyEstimatedTokens ?? activeTokens;
+    const compressionLimitTokens = typeof context?.compressionLimitTokens === "number" && Number.isFinite(context.compressionLimitTokens)
+        ? context.compressionLimitTokens
+        : undefined;
+    const promptPackTokens = typeof context?.promptPackTokens === "number" && Number.isFinite(context.promptPackTokens)
+        ? context.promptPackTokens
+        : undefined;
+    const transcriptTokens = context?.transcriptTokens ?? 0;
+    const source = observedInputTokens === undefined
+        ? context?.source ?? "application.history.estimate"
+        : context?.source ?? "provider.model-call.usage";
+    return {
+        provider: model?.provider ?? "openai",
+        model: model?.model ?? "gpt-5.5",
+        promptKind: "applicationLayer",
+        windowTokens: model?.contextWindowTokens ?? 400_000,
+        maxInputTokens: model?.maxInputTokens ?? 272_000,
+        inputBudgetThreshold: model?.inputBudgetThreshold ?? 0.95,
+        usableInputTokens: model?.usableInputTokens ?? Math.floor(272_000 * 0.95),
+        windowSource: model?.metadataSource ?? "manual-registry",
+        contextSource: source,
+        usageSource: usage?.source ?? context?.source ?? "application.history.estimate",
+        activeTokens,
+        promptTokens: activeTokens,
+        sessionContextTokens,
+        compressionLimitTokens,
+        lastRequestInputTokens: observedInputTokens,
+        lastRequestTotalTokens: observedTotalTokens,
+        promptPackTokens,
+        transcriptTokens,
+        summaryTokens: context?.summaryTokens ?? 0,
+        historyMessages: context?.historyMessages ?? 0,
+        estimated: observedInputTokens === undefined ? context?.estimated ?? true : false,
+        compacted: context?.compacted ?? false,
+    };
+}
+function isProviderBackedContext(context) {
+    if (!context) {
+        return false;
+    }
+    return context.contextSource === "provider.model-call.usage"
+        || context.usageSource === "provider.model-call.usage"
+        || typeof context.lastRequestInputTokens === "number"
+        || typeof context.lastRequestTotalTokens === "number";
+}
+function contextFor(result, options = {}) {
+    const nextContext = buildContextSnapshot(result);
+    const previousProviderContext = options.lastProviderContext;
+    if (result?.ok === false
+        && !isProviderBackedContext(nextContext)
+        && previousProviderContext !== undefined
+        && isProviderBackedContext(previousProviderContext)) {
+        return {
+            ...previousProviderContext,
+            transcriptTokens: Math.max(previousProviderContext.transcriptTokens, nextContext.transcriptTokens),
+            summaryTokens: Math.max(previousProviderContext.summaryTokens, nextContext.summaryTokens),
+            historyMessages: Math.max(previousProviderContext.historyMessages, nextContext.historyMessages),
+            retainedAfterFailure: true,
+            failureContextSource: nextContext.contextSource,
+        };
+    }
+    return nextContext;
+}
+function usageFor(result) {
+    const usage = hasUsageNumber(result.view.usage) ? result.view.usage : undefined;
+    if (usage === undefined) {
+        return { estimated: true };
+    }
+    return {
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        thinkingTokens: usage.thinkingTokens,
+        totalTokens: usage.totalTokens,
+        cachedInputTokens: usage.cachedInputTokens,
+        lastInputTokens: usage.lastInputTokens,
+        lastTotalTokens: usage.lastTotalTokens,
+        source: usage.source,
+        estimated: usage.estimated,
+    };
+}
+function directResultErrorCode(error) {
+    if (error.code !== "MODEL_INVOCATION_FAILED") {
+        return error.code;
+    }
+    const normalizedMessage = error.message.toLowerCase();
+    if (normalizedMessage.includes("provider_http_error")
+        || normalizedMessage.includes("provider_unavailable")
+        || normalizedMessage.includes("status 503")
+        || normalizedMessage.includes("upstream connect error")
+        || normalizedMessage.includes("connection timeout")) {
+        return "PROVIDER_UNAVAILABLE";
+    }
+    return error.code;
+}
+function parseApplicationTurnIndex(turnId, fallback) {
+    const parsed = Number.parseInt(turnId?.replace(/^turn\./u, "") ?? "", 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function directStreamFrameMs() {
+    const raw = Number.parseFloat(process.env.RAXODE_STREAM_FPS ?? process.env.RAXODE_RENDER_FPS ?? "120");
+    const fps = Number.isFinite(raw) && raw > 0 ? raw : 120;
+    return Math.max(1, 1000 / fps);
+}
+function chunkStreamText(text) {
+    const chars = Array.from(text);
+    const targetChunkCount = Math.max(1, Math.min(chars.length, Math.ceil(chars.length / 8)));
+    const chunkSize = Math.max(1, Math.ceil(chars.length / targetChunkCount));
+    const chunks = [];
+    for (let index = 0; index < chars.length; index += chunkSize) {
+        chunks.push(chars.slice(index, index + chunkSize).join(""));
+    }
+    return chunks;
+}
+async function waitFrame(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+function stringMetadata(metadata, key) {
+    const value = metadata?.[key];
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function stringArrayMetadata(metadata, key) {
+    const value = metadata?.[key];
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === "string" && item.trim().length > 0);
+}
+function numberMetadata(metadata, key) {
+    const value = metadata?.[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function recordMetadata(metadata, key) {
+    const value = metadata?.[key];
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function directToolStageRecord(input) {
+    if (input.applicationEvent.kind !== "tool")
+        return undefined;
+    const metadata = input.applicationEvent.metadata;
+    const toolId = stringMetadata(metadata, "toolId");
+    if (!toolId)
+        return undefined;
+    const toolStatus = stringMetadata(metadata, "toolStatus") ?? "completed";
+    const running = toolStatus === "running";
+    const humanResultSummary = running ? [] : stringArrayMetadata(metadata, "humanResultSummary");
+    const errorPreview = running || humanResultSummary.length > 0 ? undefined : stringMetadata(metadata, "errorPreview");
+    const resultMetadata = {
+        ...recordMetadata(metadata, "resultMetadata"),
+        toolCallId: stringMetadata(metadata, "toolCallId"),
+        toolId,
+        toolStatus,
+        familyKey: stringMetadata(metadata, "familyKey"),
+        familyTitle: stringMetadata(metadata, "familyTitle"),
+        inputSummary: stringMetadata(metadata, "inputSummary"),
+    };
+    return {
+        ts: input.applicationEvent.createdAt,
+        event: running ? "stage_start" : "stage_end",
+        sessionId: input.sessionId,
+        turnIndex: input.turnIndex,
+        stage: "core/capability_bridge",
+        status: running ? "running" : (toolStatus === "failed" ? "failed" : "completed"),
+        capabilityKey: toolId,
+        toolCallId: stringMetadata(metadata, "toolCallId"),
+        familyKey: stringMetadata(metadata, "familyKey"),
+        familyTitle: stringMetadata(metadata, "familyTitle"),
+        inputSummary: stringMetadata(metadata, "inputSummary"),
+        argumentsPreview: stringMetadata(metadata, "argumentsPreview"),
+        familyIntentSummary: stringMetadata(metadata, "inputSummary"),
+        output: humanResultSummary.length > 0 ? humanResultSummary.join("\n") : undefined,
+        error: errorPreview,
+        familyResultSummary: humanResultSummary.length > 0
+            ? humanResultSummary
+            : [errorPreview].filter((line) => typeof line === "string" && line.length > 0).slice(0, 3),
+        resultMetadata,
+        text: input.applicationEvent.message,
+    };
+}
+function directModelStageRecord(input) {
+    if (input.applicationEvent.kind !== "model")
+        return undefined;
+    const metadata = input.applicationEvent.metadata;
+    const modelPhase = stringMetadata(metadata, "modelPhase");
+    if (modelPhase !== "started" && modelPhase !== "completed" && modelPhase !== "failed")
+        return undefined;
+    const model = stringMetadata(metadata, "model") ?? stringMetadata(metadata, "carrierId") ?? "model";
+    const usage = recordMetadata(metadata, "usage");
+    const context = recordMetadata(metadata, "context");
+    const cacheDebug = recordMetadata(metadata, "cacheDebug");
+    return {
+        ts: input.applicationEvent.createdAt,
+        event: modelPhase === "started" ? "stage_start" : "stage_end",
+        sessionId: input.sessionId,
+        turnIndex: input.turnIndex,
+        stage: "core/model.infer",
+        status: modelPhase === "started" ? "running" : (modelPhase === "failed" ? "failed" : "completed"),
+        label: "core/model.infer",
+        text: modelPhase === "started"
+            ? `Requesting ${model} and waiting for model decision.`
+            : modelPhase === "completed"
+                ? `${model} returned a model decision.`
+                : stringMetadata(metadata, "errorMessage") ?? `${model} model request failed.`,
+        usage,
+        context,
+        cacheDebug,
+        resultMetadata: metadata,
+    };
+}
+function directToolCallPreviewRecord(input) {
+    if (input.applicationEvent.kind !== "stream")
+        return undefined;
+    const metadata = input.applicationEvent.metadata;
+    if (stringMetadata(metadata, "channel") !== "tool_call_preview")
+        return undefined;
+    const phase = stringMetadata(metadata, "phase") ?? "delta";
+    return {
+        ts: input.applicationEvent.createdAt,
+        event: "tool_call_preview",
+        sessionId: input.sessionId,
+        turnIndex: input.turnIndex,
+        status: phase,
+        stage: "core/tool_call.preview",
+        toolCallId: stringMetadata(metadata, "callId"),
+        itemId: stringMetadata(metadata, "itemId"),
+        outputIndex: numberMetadata(metadata, "outputIndex"),
+        providerToolName: stringMetadata(metadata, "providerToolName"),
+        text: input.applicationEvent.message,
+        argumentsDelta: stringMetadata(metadata, "argumentsDelta"),
+        arguments: stringMetadata(metadata, "arguments"),
+        rawType: stringMetadata(metadata, "rawType"),
+    };
+}
+function directMultiagentRecord(input) {
+    if (input.applicationEvent.kind !== "runtime")
+        return undefined;
+    const metadata = input.applicationEvent.metadata;
+    const childSessionId = stringMetadata(metadata, "childSessionId");
+    if (!childSessionId)
+        return undefined;
+    const eventId = input.applicationEvent.eventId;
+    const isSpawned = eventId.endsWith(".multiagent.spawned");
+    const isCompleted = eventId.endsWith(".multiagent.completed");
+    if (!isSpawned && !isCompleted)
+        return undefined;
+    return {
+        ts: input.applicationEvent.createdAt,
+        event: isSpawned ? "agent_session_started" : "agent_session_completed",
+        sessionId: input.sessionId,
+        turnIndex: input.turnIndex,
+        childSessionId,
+        childAgentId: stringMetadata(metadata, "childAgentId"),
+        childName: stringMetadata(metadata, "childName") ?? input.applicationEvent.message,
+        childDescription: stringMetadata(metadata, "childDescription"),
+        childLifecycle: stringMetadata(metadata, "childLifecycle"),
+        initialMessageId: stringMetadata(metadata, "initialMessageId"),
+        workspaceRoot: stringMetadata(metadata, "workingDirectory"),
+        text: input.applicationEvent.message,
+    };
+}
+function persistDirectMultiagentSession(input) {
+    const childSessionId = typeof input.record.childSessionId === "string" && input.record.childSessionId.trim()
+        ? input.record.childSessionId.trim()
+        : undefined;
+    if (!childSessionId)
+        return;
+    const now = typeof input.record.ts === "string" && input.record.ts.trim()
+        ? input.record.ts
+        : new Date().toISOString();
+    const existingAgent = listDirectTuiAgents(input.cwd).find((agent) => agent.agentId === childSessionId);
+    const existingSession = loadDirectTuiSessionSnapshot(childSessionId, input.cwd);
+    const childName = typeof input.record.childName === "string" && input.record.childName.trim()
+        ? input.record.childName.trim()
+        : existingAgent?.name ?? "agent";
+    const childDescription = typeof input.record.childDescription === "string" && input.record.childDescription.trim()
+        ? input.record.childDescription.trim()
+        : undefined;
+    const childLifecycle = typeof input.record.childLifecycle === "string" && input.record.childLifecycle.trim()
+        ? input.record.childLifecycle.trim()
+        : "persistent";
+    const workspace = typeof input.record.workspaceRoot === "string" && input.record.workspaceRoot.trim()
+        ? input.record.workspaceRoot.trim()
+        : existingAgent?.workspace ?? existingSession?.workspace ?? input.cwd;
+    const isStarted = input.record.event === "agent_session_started";
+    const status = isStarted ? "active" : "idle";
+    const summary = childDescription
+        ? `${childDescription} (${childLifecycle})`
+        : `${isStarted ? "running" : "completed"} ${childLifecycle} agent`;
+    saveDirectTuiAgent({
+        agentId: childSessionId,
+        name: childName,
+        kind: "task",
+        status,
+        summary,
+        workspace,
+        createdAt: existingAgent?.createdAt ?? existingSession?.createdAt ?? now,
+        updatedAt: now,
+        lastSessionId: childSessionId,
+    }, input.cwd);
+    saveDirectTuiSessionSnapshot({
+        schemaVersion: 1,
+        sessionId: childSessionId,
+        agentId: childSessionId,
+        name: existingSession?.name ?? childName,
+        workspace,
+        route: existingSession?.route || input.route,
+        model: existingSession?.model || input.model,
+        createdAt: existingSession?.createdAt ?? existingAgent?.createdAt ?? now,
+        updatedAt: now,
+        selectedAgentId: childSessionId,
+        agents: existingSession?.agents ?? [],
+        messages: existingSession?.messages ?? [{
+                messageId: `${childSessionId}:lifecycle`,
+                kind: "status",
+                text: summary,
+                createdAt: now,
+                updatedAt: now,
+                metadata: {
+                    source: "multiagent.lifecycle",
+                    childLifecycle,
+                    childSessionId,
+                },
+            }],
+        usageLedger: existingSession?.usageLedger ?? [],
+        exitSummary: existingSession?.exitSummary,
+    }, input.cwd);
+}
+function directSessionMessageRole(message) {
+    if (message.kind === "user")
+        return "user";
+    if (message.kind === "assistant")
+        return "assistant";
+    if (message.kind === "status") {
+        const source = typeof message.metadata?.source === "string" ? message.metadata.source : "";
+        if (source.includes("tool") || typeof message.capabilityKey === "string")
+            return "tool";
+        return "runtime-summary";
+    }
+    if (message.kind === "error")
+        return "runtime-summary";
+    return "runtime-summary";
+}
+function directSessionMessageStatus(message) {
+    if (message.status === "failed" || message.kind === "error" || message.errorCode)
+        return "failed";
+    if (message.status === "completed" || message.kind === "user" || message.kind === "assistant" || message.kind === "status") {
+        return "completed";
+    }
+    return undefined;
+}
+function directSessionSnapshotToInitialConversation(snapshot) {
+    if (!snapshot || snapshot.messages.length === 0)
+        return undefined;
+    const messages = snapshot.messages.flatMap((message) => {
+        const text = message.text.trim();
+        if (text.length === 0)
+            return [];
+        return [{
+                role: directSessionMessageRole(message),
+                text,
+                turnId: message.turnId ?? "restored",
+                createdAt: message.createdAt,
+                messageId: message.messageId,
+                metadata: {
+                    source: "raxode.directTuiSessionSnapshot",
+                    originalKind: message.kind,
+                    ...(message.title ? { title: message.title } : {}),
+                    ...(message.capabilityKey ? { capabilityKey: message.capabilityKey } : {}),
+                    ...(message.errorCode ? { errorCode: message.errorCode } : {}),
+                    ...(message.metadata ?? {}),
+                },
+                status: directSessionMessageStatus(message),
+            }];
+    });
+    if (messages.length === 0)
+        return undefined;
+    return {
+        sessionId: snapshot.sessionId,
+        messages,
+        ...(snapshot.exitSummary === undefined
+            ? {}
+            : {
+                summary: {
+                    text: `Restored Raxode direct TUI session ${snapshot.name} with ${snapshot.messages.length} persisted transcript messages and ${snapshot.exitSummary.requestCount} model requests.`,
+                    compactedMessages: 0,
+                    updatedAt: snapshot.exitSummary.generatedAt,
+                },
+            }),
+    };
+}
+export async function startDirectApplicationBackend(options = {}) {
+    const input = options.input ?? process.stdin;
+    const output = options.output ?? process.stdout;
+    const errorOutput = options.errorOutput ?? process.stderr;
+    const cwd = path.resolve(options.cwd ?? process.env.PRAXIS_WORKSPACE_ROOT ?? process.cwd());
+    const sessionId = options.sessionId ?? process.env.PRAXIS_DIRECT_SESSION_ID ?? `direct-${Date.now()}`;
+    const stateRoot = defaultStateRoot(cwd);
+    const restoredSessionSnapshot = loadDirectTuiSessionSnapshot(sessionId, cwd);
+    const restoredInitialConversation = directSessionSnapshotToInitialConversation(restoredSessionSnapshot);
+    const permissionProfile = normalizePermissionProfile(options.policyProfile
+        ?? process.env.RAXODE_APPLICATION_PERMISSION_PROFILE
+        ?? process.env.PRAXIS_PERMISSION_PROFILE);
+    const reportsDir = path.resolve(options.stateRoot ?? stateRoot, "live-reports");
+    await mkdir(reportsDir, { recursive: true });
+    const logPath = path.join(reportsDir, `direct-application-${sessionId.replace(/[^\w.-]+/gu, "_")}-${Date.now()}.jsonl`);
+    output.write(`log file: ${logPath}\n`);
+    output.write(`direct ready: ${sessionId}\n`);
+    let runtimeEventLogQueue = Promise.resolve();
+    const enqueueRuntimeEventLog = (record) => {
+        runtimeEventLogQueue = runtimeEventLogQueue.then(() => writeLog(logPath, record)).catch((error) => {
+            errorOutput.write(`direct application backend runtime event log failed: ${error instanceof Error ? error.message : String(error)}\n`);
+        });
+        return runtimeEventLogQueue;
+    };
+    const pendingRuntimeApprovals = new Map();
+    const sessionApprovedFeatures = new Set();
+    const emitRuntimeApprovalPanelSnapshot = () => enqueueRuntimeEventLog({
+        ts: options.now?.() ?? new Date().toISOString(),
+        event: "panel_snapshot",
+        sessionId,
+        panel: "capabilities",
+        snapshot: buildRuntimeApprovalPanelSnapshot(pendingRuntimeApprovals, () => options.now?.() ?? new Date().toISOString()),
+    });
+    const resolveHumanGateDecisionPayload = (decision) => {
+        const pending = pendingRuntimeApprovals.get(decision.gateId);
+        if (!pending)
+            return false;
+        pendingRuntimeApprovals.delete(decision.gateId);
+        if (decision.action === "approve_always") {
+            sessionApprovedFeatures.add(pending.featureKey);
+        }
+        void enqueueRuntimeEventLog({
+            ts: options.now?.() ?? new Date().toISOString(),
+            event: "approval_decision",
+            sessionId,
+            approvalId: decision.gateId,
+            featureKey: pending.featureKey,
+            action: decision.action,
+            note: decision.note,
+        });
+        void emitRuntimeApprovalPanelSnapshot();
+        pending.resolve(approvalDecisionToRuntimeResolution({ decision, pending }));
+        return true;
+    };
+    const approvalResolver = async (envelope) => {
+        const feature = inferRuntimeApprovalFeature(envelope);
+        if (sessionApprovedFeatures.has(feature.featureKey)) {
+            return {
+                status: "approved",
+                resolvedBy: "raxode.tui.session_approval_cache",
+                reason: `${feature.featureDisplay} was already approved for this session.`,
+                metadata: {
+                    approvalId: envelope.approvalId,
+                    featureKey: feature.featureKey,
+                    featureDisplay: feature.featureDisplay,
+                    ...(feature.toolId ? { toolId: feature.toolId } : {}),
+                },
+            };
+        }
+        const resolution = new Promise((resolve) => {
+            pendingRuntimeApprovals.set(envelope.approvalId, {
+                envelope,
+                featureKey: feature.featureKey,
+                featureDisplay: feature.featureDisplay,
+                resolve,
+                ...(feature.toolId ? { toolId: feature.toolId } : {}),
+            });
+        });
+        await enqueueRuntimeEventLog({
+            ts: options.now?.() ?? new Date().toISOString(),
+            event: "approval_requested",
+            sessionId,
+            approvalId: envelope.approvalId,
+            featureKey: feature.featureKey,
+            featureDisplay: feature.featureDisplay,
+            toolId: feature.toolId,
+            reason: envelope.reason,
+            riskLevel: envelope.riskLevel,
+        });
+        await emitRuntimeApprovalPanelSnapshot();
+        return resolution;
+    };
+    const inputClosed = new Promise((resolve) => {
+        let done = false;
+        const finish = () => {
+            if (done)
+                return;
+            done = true;
+            resolve();
+        };
+        input.on("end", finish);
+        input.on("close", finish);
+    });
+    let buffer = "";
+    let payloadQueue = Promise.resolve();
+    const pendingPayloads = [];
+    let handlePayloadImpl = null;
+    const enqueuePayload = (rawPayload) => {
+        if (!handlePayloadImpl) {
+            pendingPayloads.push(rawPayload);
+            return;
+        }
+        const handler = handlePayloadImpl;
+        payloadQueue = payloadQueue.then(() => handler(rawPayload)).catch((error) => {
+            errorOutput.write(`direct application backend payload failed: ${error instanceof Error ? error.message : String(error)}\n`);
+        });
+    };
+    input.setEncoding("utf8");
+    input.on("data", (chunk) => {
+        buffer += chunk;
+        const parts = buffer.split("\u0000");
+        buffer = parts.pop() ?? "";
+        for (const part of parts) {
+            const decision = parseDirectHumanGateDecision(part);
+            if (decision && resolveHumanGateDecisionPayload(decision)) {
+                continue;
+            }
+            enqueuePayload(part);
+        }
+    });
+    const [applicationLayer, liveProviderModule, applicationModule, readinessModule,] = await Promise.all([
+        import("@praxis-ai/praxis/application-layer"),
+        import("./authentication/liveProvider.js"),
+        import("./application/raxodeApplication.js"),
+        import("./application/runtimeReadiness.js"),
+    ]);
+    const modelOptions = liveProviderModule.resolveRaxodeConfiguredModelOptions({
+        roleId: "core.main",
+        startDir: cwd,
+    });
+    const provider = options.provider ?? modelOptions.provider;
+    const endpointShape = options.endpointShape ?? modelOptions.endpointShape;
+    const baseURL = options.baseURL ?? modelOptions.baseURL;
+    const providerRoute = options.providerRoute ?? modelOptions.providerRoute;
+    const model = options.model ?? modelOptions.model;
+    const reasoningEffort = options.reasoningEffort ?? modelOptions.reasoningEffort;
+    const maxOutputTokens = options.maxOutputTokens ?? modelOptions.maxOutputTokens;
+    const compactOptions = resolveDirectCompactOptions(options);
+    const projectRoot = path.resolve(options.projectRoot ?? defaultProjectRoot());
+    const memoryBridge = await inspectRaxodeMemoryBridge({
+        projectRoot,
+        cwd,
+        profile: options.memoryProfile,
+        now: options.now,
+    });
+    const agentOptions = {
+        policyProfile: permissionProfile,
+        sandboxProfile: options.sandboxProfile,
+        persistence: options.persistence,
+        includeAllCatalogTools: options.includeAllCatalogTools,
+        provider,
+        endpointShape,
+        baseURL,
+        providerRoute,
+        model,
+        reasoningEffort,
+        maxOutputTokens,
+        memoryProfile: memoryBridge.profile,
+        memoryPromptGuide: memoryBridge.promptGuide,
+    };
+    const created = await applicationLayer.createApplicationProjectRuntime(projectRoot, {
+        applicationId: applicationModule.raxodeApplication.id,
+        cwd,
+        mode: resolveDirectApplicationMode(options.mode),
+        provider,
+        endpointShape,
+        baseURL,
+        providerRoute,
+        model,
+        reasoningEffort,
+        maxOutputTokens,
+        permissionProfile,
+        agentOptions,
+        initialConversations: restoredInitialConversation === undefined ? [] : [restoredInitialConversation],
+        now: options.now,
+        compactExecutor: options.compactExecutor,
+        preCompactGovernanceExecutor: options.preCompactGovernanceExecutor,
+        preCompactGovernanceEnabled: options.preCompactGovernanceEnabled,
+        compactContextWindowTokens: compactOptions.compactContextWindowTokens,
+        compactThresholdRatio: compactOptions.compactThresholdRatio,
+        liveProviderResolver: options.liveProviderResolver ?? (async (manifest, context) => liveProviderModule.createRaxodeLiveProvider(manifest, {
+            startDir: cwd,
+            sessionId: context?.sessionId,
+            runtimeId: context?.runtimeId,
+            turnId: context?.turnId,
+            onTextDelta: context?.onTextDelta,
+            onProviderStreamEvent: context?.onProviderStreamEvent,
+        })),
+        approvalResolver,
+    });
+    if (!created.ok) {
+        await writeLog(logPath, {
+            ts: options.now?.() ?? new Date().toISOString(),
+            event: "stage_end",
+            sessionId,
+            turnIndex: 0,
+            stage: "application/start",
+            status: "failed",
+            text: created.error.message,
+        });
+        errorOutput.write(`direct application backend failed: ${created.error.message}\n`);
+        return;
+    }
+    const transport = applicationLayer.createLocalApplicationTransport(created.runtime);
+    const streamedTextByTurn = new Map();
+    const directTurnIndexByApplicationTurnId = new Map();
+    const initialTurnIndex = normalizeInitialTurnIndex(options.initialTurnIndex ?? process.env.PRAXIS_DIRECT_INITIAL_TURN_INDEX);
+    let turnIndex = initialTurnIndex;
+    let activeDirectTurnIndex;
+    let lastProviderContext;
+    transport.subscribe((applicationEvent) => {
+        const directTurnIndex = (() => {
+            const applicationTurnId = applicationEvent.turnId;
+            if (applicationTurnId) {
+                const existing = directTurnIndexByApplicationTurnId.get(applicationTurnId);
+                if (existing !== undefined) {
+                    return existing;
+                }
+                if (activeDirectTurnIndex !== undefined) {
+                    directTurnIndexByApplicationTurnId.set(applicationTurnId, activeDirectTurnIndex);
+                    return activeDirectTurnIndex;
+                }
+            }
+            return parseApplicationTurnIndex(applicationTurnId, turnIndex || 1);
+        })();
+        const modelStageRecord = directModelStageRecord({
+            applicationEvent,
+            sessionId,
+            turnIndex: directTurnIndex,
+        });
+        if (modelStageRecord) {
+            const modelContext = recordMetadata(modelStageRecord, "context");
+            if (isProviderBackedContext(modelContext)) {
+                lastProviderContext = modelContext;
+            }
+            void enqueueRuntimeEventLog(modelStageRecord);
+            return;
+        }
+        const toolStageRecord = directToolStageRecord({
+            applicationEvent,
+            sessionId,
+            turnIndex: directTurnIndex,
+        });
+        if (toolStageRecord) {
+            void enqueueRuntimeEventLog(toolStageRecord);
+            return;
+        }
+        const toolCallPreviewRecord = directToolCallPreviewRecord({
+            applicationEvent,
+            sessionId,
+            turnIndex: directTurnIndex,
+        });
+        if (toolCallPreviewRecord) {
+            void enqueueRuntimeEventLog(toolCallPreviewRecord);
+            return;
+        }
+        const multiagentRecord = directMultiagentRecord({
+            applicationEvent,
+            sessionId,
+            turnIndex: directTurnIndex,
+        });
+        if (multiagentRecord) {
+            persistDirectMultiagentSession({
+                record: multiagentRecord,
+                cwd,
+                route: baseURL ?? providerRoute ?? provider ?? "(unconfigured)",
+                model,
+            });
+            void enqueueRuntimeEventLog(multiagentRecord);
+            return;
+        }
+        if (applicationEvent.kind !== "stream" || applicationEvent.message.length === 0) {
+            return;
+        }
+        streamedTextByTurn.set(directTurnIndex, `${streamedTextByTurn.get(directTurnIndex) ?? ""}${applicationEvent.message}`);
+        void enqueueRuntimeEventLog({
+            ts: applicationEvent.createdAt,
+            event: "assistant_delta",
+            sessionId,
+            turnIndex: directTurnIndex,
+            label: "core/model.infer",
+            text: applicationEvent.message,
+            done: false,
+        });
+    });
+    const start = await transport.dispatch({
+        type: "application.start",
+        sessionId,
+        cwd,
+        mode: resolveDirectApplicationMode(options.mode),
+    });
+    const readiness = readinessModule.inspectRaxodeBackendReadinessWithLocalProbe({
+        view: start.view,
+        options: agentOptions,
+        now: options.now,
+        localProbe: options.localReadinessProbe,
+        ports: {
+            approvalResolver: "configured",
+            liveProviderResolver: options.liveProviderResolver ? "configured" : "raxode-default",
+        },
+    });
+    output.write(`backend readiness: ${JSON.stringify(readiness)}\n`);
+    await writeLog(logPath, {
+        ts: options.now?.() ?? new Date().toISOString(),
+        event: "session_start",
+        sessionId,
+        initialTurnIndex,
+        context: contextFor(start, { lastProviderContext }),
+    });
+    await writeLog(logPath, {
+        ts: readiness.generatedAt,
+        event: "backend_readiness",
+        sessionId,
+        status: readiness.areas.some((area) => area.status === "missing")
+            ? "missing"
+            : readiness.areas.some((area) => area.status === "degraded")
+                ? "degraded"
+                : "ready",
+        toolProfile: readiness.toolProfile,
+        permissionProfile: readiness.permissionProfile,
+        sandboxProfile: readiness.sandboxProfile,
+        moduleInventory: readiness.moduleInventory,
+        readiness,
+    });
+    const handlePayload = async (rawPayload) => {
+        const payload = rawPayload.trim();
+        if (!payload)
+            return;
+        await writeLog(logPath, {
+            ts: options.now?.() ?? new Date().toISOString(),
+            event: "stdin_payload_received",
+            sessionId,
+            byteLength: Buffer.byteLength(rawPayload, "utf8"),
+            preview: payload.slice(0, 120),
+        });
+        if (payload === "/exit" || payload === "/quit") {
+            await transport.dispatch({ type: "application.close", sessionId });
+            if ("destroy" in input && typeof input.destroy === "function") {
+                input.destroy();
+            }
+            return;
+        }
+        if (payload.startsWith("/rewind")) {
+            await transport.dispatch({ type: "application.rewind", sessionId, turnIndex: Math.max(0, turnIndex - 1) });
+            directTurnIndexByApplicationTurnId.clear();
+            await writeLog(logPath, {
+                ts: options.now?.() ?? new Date().toISOString(),
+                event: "rewind_applied",
+                sessionId,
+                targetTurnId: String(Math.max(0, turnIndex - 1)),
+            });
+            return;
+        }
+        const normalized = normalizeDirectPayload(payload);
+        turnIndex += 1;
+        const turnStartedAt = options.now?.() ?? new Date().toISOString();
+        await writeLog(logPath, {
+            ts: turnStartedAt,
+            event: "turn_start",
+            sessionId,
+            turnIndex,
+            userMessage: normalized.text,
+            inputSource: normalized.inputSource,
+            context: contextFor(start, { lastProviderContext }),
+        });
+        await writeLog(logPath, {
+            ts: turnStartedAt,
+            event: "stage_start",
+            sessionId,
+            turnIndex,
+            stage: "core/run",
+            status: "running",
+            text: "Raxode application backend is running.",
+        });
+        const dispatchStartedAtMs = Date.now();
+        activeDirectTurnIndex = turnIndex;
+        const result = await (async () => {
+            try {
+                return await transport.dispatch({
+                    type: "application.submitTurn",
+                    sessionId,
+                    mode: resolveDirectApplicationMode(options.mode),
+                    input: {
+                        type: "application.input",
+                        text: normalized.text,
+                        attachments: normalized.attachments,
+                        cwd,
+                    },
+                });
+            }
+            finally {
+                activeDirectTurnIndex = undefined;
+            }
+        })();
+        const dispatchElapsedMs = Math.max(0, Date.now() - dispatchStartedAtMs);
+        await runtimeEventLogQueue;
+        const finalText = result.view.finalOutput ?? result.view.error?.message ?? "";
+        if (finalText.length > 0 && (streamedTextByTurn.get(turnIndex) ?? "").length === 0) {
+            for (const chunk of chunkStreamText(finalText)) {
+                await writeLog(logPath, {
+                    ts: options.now?.() ?? new Date().toISOString(),
+                    event: "assistant_delta",
+                    sessionId,
+                    turnIndex,
+                    label: "core/model.infer",
+                    text: chunk,
+                    done: false,
+                });
+                await waitFrame(directStreamFrameMs());
+            }
+        }
+        const completedAt = options.now?.() ?? new Date().toISOString();
+        await writeLog(logPath, {
+            ts: completedAt,
+            event: "stage_end",
+            sessionId,
+            turnIndex,
+            stage: "core/run",
+            status: result.ok ? "completed" : "failed",
+            text: result.ok ? "Raxode application backend completed." : result.view.error?.message ?? "Raxode application backend failed.",
+        });
+        const finalContext = contextFor(result, { lastProviderContext });
+        if (isProviderBackedContext(finalContext)) {
+            lastProviderContext = finalContext;
+        }
+        const resultMetadata = result.ok
+            ? undefined
+            : {
+                errorCode: directResultErrorCode(result.view.error ?? result.error),
+                errorMessage: result.view.error?.message ?? result.error.message,
+            };
+        await writeLog(logPath, {
+            ts: completedAt,
+            event: "turn_result",
+            sessionId,
+            turnIndex,
+            elapsedMs: dispatchElapsedMs,
+            core: {
+                answer: finalText,
+                dispatchStatus: result.ok ? "completed" : "failed",
+                taskStatus: result.ok ? "completed" : "failed",
+                context: finalContext,
+                usage: usageFor(result),
+                elapsedMs: dispatchElapsedMs,
+            },
+            context: finalContext,
+            resultMetadata,
+        });
+    };
+    handlePayloadImpl = handlePayload;
+    for (const pendingPayload of pendingPayloads.splice(0)) {
+        enqueuePayload(pendingPayload);
+    }
+    await inputClosed;
+    await payloadQueue;
+    await writeLog(logPath, {
+        ts: options.now?.() ?? new Date().toISOString(),
+        event: "session_end",
+        sessionId,
+    });
+}
+if (import.meta.url === pathToFileURL(process.argv[1] ?? "").href) {
+    await startDirectApplicationBackend();
+}