open-multi-agent-kit 0.79.1 → 0.79.3

package/dist/commands/chat/native-root-loop.js

@@ -0,0 +1,1263 @@
+import { style } from "../../util/theme.js";
+import { runShell } from "../../util/shell.js";
+import { createDag } from "../../orchestration/dag.js";
+import { applyCapabilityInjectionToRouting, buildCapabilityInjection, } from "../../runtime/capability-injection.js";
+import { capabilityScopesFromRouting } from "../../orchestration/capability-routing.js";
+import { decideToolAuthority, } from "../../safety/tool-authority-gate.js";
+import { resolveToolAuthorityEnforcement } from "../../runtime/tool-dispatch-contracts.js";
+import { compileBloatToNlp, } from "../../runtime/debloat-nlp.js";
+import { buildPromptEnvelope, renderPromptEnvelope, } from "../../runtime/prompt-envelope.js";
+import { buildTaskRunContext } from "../../runtime/worker-manifest.js";
+import { buildInputEnvelope, normalizeMcpScope, } from "../../input/input-envelope.js";
+import { persistInputEnvelope } from "../../input/input-artifacts.js";
+import { buildDagCompileResult } from "../../orchestration/dag-compiler.js";
+import { persistDagCompileArtifacts } from "../../orchestration/dag-artifacts.js";
+import { TerminalOwner } from "../../util/terminal-owner.js";
+import { resumeInteractiveInput } from "../../util/terminal-input.js";
+import { executeHarnessRun } from "../../harness/execute-harness-run.js";
+import { normalizeProviderId, readProviderRegistry } from "../../providers/model-registry.js";
+import { renderProviderModelTable } from "../../providers/model-table.js";
+import { ALL_PROVIDER_TAB, buildProviderTabs, createModelPickerState, debugModelTabs, handleModelPickerKey, initializeModelPickerState, normalizeProviderTab, providerTabIdForProvider, } from "../../providers/model-tabs.js";
+import { formatThinkingModelVariant, nextThinkingLevel, thinkingLevelsFor } from "../../providers/thinking-levels.js";
+import { buildChatTurnDag } from "./chat-turn-dag.js";
+import { createSlashCommandContext } from "./slash/context.js";
+import { buildNativeChatSlashCommands } from "./slash/commands/index.js";
+import { parseSlashInput } from "./slash/parser.js";
+import { createSlashCommandRegistry } from "./slash/registry.js";
+import { emitSlashResult, okSlashResult, printSlashResult, } from "./slash/result.js";
+async function runSlashHandler(handler, parsed, ctx, options = {}) {
+    const result = await handler.handler(ctx, parsed.args);
+    const normalized = result ?? okSlashResult();
+    if (normalized.statePatch)
+        Object.assign(ctx.state, normalized.statePatch);
+    const visibleResult = options.suppressOutput
+        ? { ...normalized, text: undefined, json: undefined, events: [] }
+        : normalized;
+    if (ctx.renderer)
+        emitSlashResult(visibleResult, ctx.renderer);
+    else
+        printSlashResult(visibleResult);
+    return normalized;
+}
+function isModelSlashCommand(parsed) {
+    return parsed.command === "/model" || parsed.command === "/m";
+}
+function isModelShowSlash(parsed) {
+    return isModelSlashCommand(parsed)
+        && parsed.args.positional.length === 0
+        && parsed.args.flags.json !== true;
+}
+function explicitProviderTabFromModelLine(line, providerIds) {
+    const trimmed = line.trim();
+    if (!/^\/(?:model|m)(?:\s|$)/.test(trimmed)) {
+        return undefined;
+    }
+    const tokens = trimmed.split(/\s+/);
+    const rawArg = tokens[1];
+    if (!rawArg) {
+        return undefined;
+    }
+    const slashIndex = rawArg.indexOf("/");
+    const providerPart = (slashIndex > 0 ? rawArg.slice(0, slashIndex) : rawArg)
+        .split(":")[0]
+        ?.trim()
+        .toLowerCase();
+    if (!providerPart) {
+        return undefined;
+    }
+    const tabs = buildProviderTabs(providerIds);
+    if (tabs.includes(providerPart)) {
+        return providerPart;
+    }
+    const normalized = normalizeProviderId(providerPart);
+    const normalizedTab = normalized === "auto" ? null : providerTabIdForProvider(normalized);
+    if (normalizedTab && tabs.includes(normalizedTab)) {
+        return normalizedTab;
+    }
+    return undefined;
+}
+function isModelPickerLine(line, state) {
+    const trimmed = line.trim();
+    return /^\/(?:model|m)(?:\s|$)/.test(trimmed)
+        || (state.modelPickerOpen === true && state.thinkingPickerOpen !== true && trimmed.length === 0);
+}
+function isThinkingPickerLine(line, state) {
+    const trimmed = line.trim();
+    return (state.thinkingPickerOpen === true && trimmed.length === 0)
+        || (state.modelPickerOpen !== true && trimmed.length === 0);
+}
+function isThinkingSlashCommand(parsed) {
+    return parsed.command === "/think" || parsed.command === "/thinking" || parsed.command === ":think";
+}
+function isThinkingShowSlash(parsed) {
+    return isThinkingSlashCommand(parsed)
+        && parsed.args.positional.length === 0
+        && parsed.args.flags.json !== true;
+}
+function isThinkingFollowupSlash(parsed) {
+    return parsed.command === "/model"
+        || parsed.command === "/m"
+        || parsed.command === "/use"
+        || parsed.command === ":use";
+}
+function shouldOpenThinkingPickerAfterSlash(parsed, result) {
+    if (!result.ok || !isThinkingFollowupSlash(parsed))
+        return false;
+    if (parsed.args.positional.length === 0)
+        return false;
+    if (result.statePatch?.thinking)
+        return false;
+    return Boolean(result.statePatch?.model || result.statePatch?.provider || result.statePatch?.bootstrap);
+}
+function renderThinkingPickerText(state) {
+    const levels = thinkingLevelsFor(state.provider, state.model);
+    const current = state.thinking;
+    const levelLine = levels
+        .map((level) => {
+        const label = `${level === current ? "●" : "○"} ${level}`;
+        if (level === current)
+            return style.mintBold(label);
+        if (level === "max" || level === "xhigh")
+            return style.cyanBold(label);
+        return style.gray(label);
+    })
+        .join(style.gray("  "));
+    const active = current
+        ? `${current} (${formatThinkingModelVariant(state.model, current)})`
+        : "not selected";
+    const firstLevel = levels[0] ?? "medium";
+    return [
+        style.phosphorBold("\n  OMK Thinking Control · choose level"),
+        style.phosphorDim(`  Target: ${state.provider ?? "auto"}/${state.model ?? "auto"}`),
+        `  ${levelLine}`,
+        style.phosphorDim("  Press Tab on an empty prompt to cycle, or run /think <level>."),
+        style.phosphorDim(`  Shortcut: /model ${state.provider ?? "auto"}/${state.model ?? "auto"}:${firstLevel}`),
+        style.phosphorDim(`  Active: ${active}\n`),
+    ].join("\n");
+}
+function canUseInteractiveThinkingSelector(input, renderer) {
+    if (renderer)
+        return false;
+    if (isDisabledEnvValue(input.env.OMK_INTERACTIVE_THINKING_SELECT))
+        return false;
+    return process.stdin.isTTY === true && process.stderr.isTTY === true;
+}
+function applyThinkingLevelToNativeState(input, state, level) {
+    state.thinking = level;
+    state.thinkingPickerOpen = true;
+    state.modelPickerOpen = false;
+    state.updatedAt = new Date().toISOString();
+    input.env.OMK_THINKING = level;
+    input.env.OMK_MODEL_VARIANT = formatThinkingModelVariant(state.model, level);
+}
+async function promptThinkingSelection(input, state, renderer) {
+    if (!canUseInteractiveThinkingSelector(input, renderer))
+        return false;
+    const levels = thinkingLevelsFor(state.provider, state.model);
+    if (levels.length === 0)
+        return false;
+    try {
+        const { select } = await import("@inquirer/prompts");
+        const selected = await select({
+            message: `Select thinking level for ${state.provider ?? "auto"}/${state.model ?? "auto"}`,
+            choices: levels.map((level) => ({
+                value: level,
+                name: `${level === state.thinking ? "● " : ""}${level}`,
+                description: formatThinkingModelVariant(state.model, level),
+            })),
+            pageSize: Math.min(levels.length, 8),
+            loop: true,
+            default: state.thinking ?? input.env.OMK_THINKING ?? levels[0],
+        }, {
+            input: process.stdin,
+            output: process.stderr,
+            clearPromptOnDone: true,
+        });
+        applyThinkingLevelToNativeState(input, state, selected);
+        process.stderr.write(style.phosphorDim(`\n  Thinking variant: ${selected}\n  Active: ${input.env.OMK_MODEL_VARIANT}\n`));
+        return true;
+    }
+    catch (err) {
+        const name = err instanceof Error ? err.name : "Error";
+        if (name === "ExitPromptError") {
+            process.stderr.write(style.phosphorDim("\n  Thinking selection cancelled.\n"));
+            return true;
+        }
+        return false;
+    }
+}
+function countModelPickerRows(registry, activeProviderTab) {
+    return registry
+        .filter((entry) => activeProviderTab === ALL_PROVIDER_TAB || providerTabIdForProvider(entry.id) === activeProviderTab)
+        .reduce((count, entry) => count + 1 + Object.keys(entry.aliases).length, 0);
+}
+function isDisabledEnvValue(value) {
+    const normalized = value?.trim().toLowerCase();
+    return (normalized === "0" ||
+        normalized === "false" ||
+        normalized === "no" ||
+        normalized === "off");
+}
+export function shouldRunNativeParallelTurn(executionPrompt) {
+    return executionPrompt?.trim().toLowerCase() === "parallel";
+}
+export function buildNativeParallelTurnArgs(input, prompt) {
+    const args = ["dist/cli.js", "parallel", prompt, "--execution", "parallel", "--chat"];
+    if (input.workers && input.workers > 0) {
+        args.push("--workers", String(input.workers));
+    }
+    const provider = input.bootstrap.providerPolicy || input.bootstrap.provider;
+    if (provider) {
+        args.push("--provider", provider);
+    }
+    const model = input.env.OMK_MODEL_VARIANT
+        ?? input.bootstrap.selectedModel
+        ?? input.env.OMK_PROVIDER_MODEL
+        ?? input.env.OMK_MODEL;
+    if (model) {
+        args.push("--model", model);
+    }
+    const mcpScope = input.env.OMK_MCP_SCOPE;
+    if (mcpScope === "all" || mcpScope === "project" || mcpScope === "none") {
+        args.push("--mcp-scope", mcpScope);
+    }
+    return args;
+}
+function buildNativeParallelTurnEnv(input) {
+    return {
+        ...input.env,
+        OMK_PARALLEL_PARENT_RUN_ID: input.runId,
+        OMK_PARALLEL_PARENT_MCP: (input.mcpAllowlist ?? []).join(","),
+        OMK_PARALLEL_PARENT_SKILLS: (input.skillNames ?? []).join(","),
+        OMK_PARALLEL_PARENT_HOOKS: (input.hookNames ?? []).join(","),
+    };
+}
+async function runNativeParallelTurn(input, prompt, renderer) {
+    const normalizedPrompt = prompt.trim();
+    const message = `\n  Spawning parallel: "${normalizedPrompt}"\n`;
+    if (renderer) {
+        renderer.emit({ type: "control:output", text: message });
+    }
+    else {
+        console.log(style.phosphorDim(message));
+    }
+    const result = await runShell(process.execPath, buildNativeParallelTurnArgs(input, normalizedPrompt), {
+        cwd: input.root,
+        env: buildNativeParallelTurnEnv(input),
+        stdio: "inherit",
+        timeout: 300000,
+    });
+    if (result.failed) {
+        const errorMessage = `Parallel exited with code ${result.exitCode}`;
+        if (renderer) {
+            renderer.emit({ type: "turn:error", message: errorMessage });
+        }
+        else {
+            console.log(style.metricsRed(errorMessage));
+        }
+    }
+    return result.exitCode ?? (result.failed ? 1 : 0);
+}
+function nativeApprovalPolicy(executionPrompt) {
+    const normalized = executionPrompt?.trim().toLowerCase();
+    switch (normalized) {
+        case "block":
+            return "block";
+        case "yolo":
+            return "yolo";
+        case "auto":
+        case "parallel":
+        case "sequential":
+            return "auto";
+        case "ask":
+        default:
+            return "interactive";
+    }
+}
+function nativeExecutionStrategy(executionPrompt) {
+    const normalized = executionPrompt?.trim().toLowerCase();
+    if (normalized === "sequential" || normalized === "parallel")
+        return normalized;
+    return undefined;
+}
+function bootstrapProviderPolicy(bootstrap) {
+    const raw = (bootstrap.providerPolicy || bootstrap.provider || "auto")
+        .trim()
+        .toLowerCase();
+    switch (raw) {
+        case "auto":
+        case "authority":
+        case "codex":
+        case "commandcode":
+        case "deepseek":
+        case "kimi":
+        case "local-llm":
+        case "mimo":
+        case "opencode":
+        case "openrouter":
+        case "qwen":
+            return raw;
+        case "local":
+        case "llama":
+            return "local-llm";
+        default:
+            return "auto";
+    }
+}
+function nativeTurnRiskToToolOp(risk) {
+    switch (risk) {
+        case "merge":
+            return "merge";
+        case "shell":
+            return "shell";
+        case "write":
+            return "write";
+        default:
+            return "read";
+    }
+}
+/**
+ * Shadow-only tool-authority observability at the live turn dispatch
+ * checkpoint. The kimi runner executes tools inside a spawned CLI, so per-tool
+ * enforcement lives in dispatchToolCallsByContract; here we only compute and
+ * record the turn-level verdict for the trace. Default output is byte-identical
+ * (emitted only under OMK_DEBUG / OMK_TOOL_AUTHORITY_TRACE); this path never
+ * blocks dispatch.
+ */
+function recordNativeTurnToolAuthority(input) {
+    const traceEnabled = input.env.OMK_DEBUG === "1" ||
+        /^(1|true|yes|on)$/i.test(input.env.OMK_TOOL_AUTHORITY_TRACE ?? "");
+    if (!traceEnabled)
+        return;
+    const routing = input.node.routing;
+    const scopes = capabilityScopesFromRouting(routing);
+    const op = nativeTurnRiskToToolOp(routing?.risk);
+    const enforce = resolveToolAuthorityEnforcement(input.env);
+    const decision = decideToolAuthority({
+        op,
+        writeAuthority: scopes.writeAuthority,
+        shellAuthority: scopes.shellAuthority,
+        approvalPolicy: nativeApprovalPolicy(routing?.approvalPolicy ?? routing?.executionPrompt),
+        sandboxMode: routing?.sandboxMode === "read-only" ? "read-only" : "workspace-write",
+        tty: Boolean(process.stdout.isTTY),
+    });
+    const line = `  tool-authority(${enforce ? "enforce" : "shadow"}): node=${input.node.id} ` +
+        `op=${op} decision=${decision} write=${scopes.writeAuthority} ` +
+        `shell=${scopes.shellAuthority} sandbox=${routing?.sandboxMode ?? "auto"}\n`;
+    if (input.renderer) {
+        input.renderer.emit({ type: "control:output", text: style.phosphorDim(line) });
+    }
+    else {
+        process.stderr.write(style.phosphorDim(line));
+    }
+}
+function emitNativeTurnRoute(input) {
+    if (!input.heartbeatEnabled)
+        return;
+    const routing = input.node.routing;
+    if (input.renderer) {
+        input.renderer.emit({
+            type: "turn:route",
+            provider: routing?.provider ?? "auto",
+            model: routing?.providerModel ?? input.env.OMK_PROVIDER_MODEL,
+            risk: String(routing?.risk ?? "read"),
+            sandbox: String(routing?.sandboxMode ?? "auto"),
+            mcp: input.mcpAllowlist,
+            skills: input.skillNames,
+            hooks: input.hookNames,
+        });
+        return;
+    }
+    process.stderr.write(style.phosphorDim(`  routing: provider=${routing?.provider ?? "auto"} model=${routing?.providerModel ?? input.env.OMK_PROVIDER_MODEL ?? "auto"} risk=${routing?.risk ?? "read"} sandbox=${routing?.sandboxMode ?? "auto"}\n`));
+}
+export function createNativeRootSessionState(input) {
+    return {
+        bootstrap: input.bootstrap,
+        provider: input.bootstrap.provider,
+        model: input.bootstrap.selectedModel,
+        approvalPolicy: input.executionPrompt,
+        theme: "system24",
+        view: "summary",
+    };
+}
+function buildNativeInputEnvelope(input) {
+    return buildInputEnvelope({
+        runId: input.loopInput.runId,
+        kind: input.parsedSlash ? "slash-command" : "plain-prompt",
+        raw: input.line,
+        source: "chat",
+        cwd: input.loopInput.activeCwd ?? process.cwd(),
+        root: input.loopInput.root,
+        rootSource: input.loopInput.rootSource,
+        provider: input.state.provider,
+        model: input.state.model,
+        mcpScope: normalizeMcpScope(input.loopInput.env.OMK_MCP_SCOPE),
+        ui: input.loopInput.env.OMK_UI ?? input.loopInput.env.OMK_CHAT_UI,
+        view: input.state.view ?? input.loopInput.env.OMK_TUI_VIEW,
+        theme: input.state.theme,
+        constraints: [],
+        requestedArtifacts: [],
+        slashCommand: input.parsedSlash
+            ? slashCommandToEnvelope(input.parsedSlash)
+            : undefined,
+    });
+}
+function slashCommandToEnvelope(parsed) {
+    const flags = {};
+    for (const [key, value] of Object.entries(parsed.args.flags)) {
+        if (Array.isArray(value))
+            flags[key] = [...value];
+        else if (typeof value === "boolean" || typeof value === "string")
+            flags[key] = value;
+    }
+    return {
+        command: parsed.command,
+        argv: [...parsed.args.argv],
+        positional: [...parsed.args.positional],
+        flags,
+    };
+}
+async function persistNativeInputEnvelope(input) {
+    try {
+        await persistInputEnvelope(input.envelope, { root: input.root });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const text = `InputEnvelope artifact write failed: ${message}`;
+        if (input.renderer)
+            input.renderer.emit({ type: "turn:error", message: text });
+        else
+            process.stderr.write(style.metricsRed(text) + "\n");
+    }
+}
+async function persistNativeDagCompileArtifacts(input) {
+    try {
+        await persistDagCompileArtifacts(buildDagCompileResult({
+            input: input.envelope,
+            dag: input.dag,
+            workerCount: input.workerCount,
+            executionStrategy: input.executionStrategy,
+            explanation: input.explanation,
+        }), { root: input.root });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const text = `DAG compile artifact write failed: ${message}`;
+        if (input.renderer)
+            input.renderer.emit({ type: "turn:error", message: text });
+        else
+            process.stderr.write(style.metricsRed(text) + "\n");
+    }
+}
+const API_ADVISORY_PROVIDERS = new Set([
+    "deepseek",
+    "kimi",
+    "local-llm",
+    "mimo",
+    "openrouter",
+    "qwen",
+]);
+function hasExplicitReadOnlyIntent(text) {
+    return (/\b(read|inspect|look|show|list|summarize|explain|describe|review|audit|status|diagnose)\b/.test(text) ||
+        /\b(without changing|without editing|do not change|don't change|do not edit|don't edit|no edits?|no file changes?)\b/.test(text) ||
+        /읽기\s*전용|수정하지\s*말|변경하지\s*말|파일\s*(수정|변경)\s*(없이|하지\s*말)|요약|설명|상태|검토만|분석만|읽어|살펴/.test(text));
+}
+export function inferNativeTurnRisk(prompt) {
+    const text = prompt.toLowerCase();
+    if (/\b(push|publish|release|merge|tag|deploy)\b|푸시|퍼블리시|릴리즈|머지|배포/.test(text))
+        return "merge";
+    if (/\b(run|test|build|exec|execute|shell|terminal|command|npm|pnpm|yarn|bun|pytest|cargo|go test|tsc|lint|verify|check)\b|테스트|빌드|실행|검증|쉘|터미널/.test(text))
+        return "shell";
+    if (/\b(fix|edit|write|implement|modify|patch|refactor|add|create|delete|update|change)\b|수정|구현|패치|리팩터|추가|삭제|변경/.test(text))
+        return "write";
+    if (hasExplicitReadOnlyIntent(text))
+        return "read";
+    return "write";
+}
+function nativeTurnRoutingPolicy(provider, risk) {
+    if (isApiAdvisoryProvider(provider) && risk !== "read") {
+        return {
+            capabilities: ["read", "review", "advisory"],
+            readOnly: true,
+            sandboxMode: "read-only",
+            providerReasonSuffix: `; ${provider} API is advisory/read-only for ${risk} intent; OMK owns write, shell, MCP, and merge authority`,
+        };
+    }
+    if (risk === "read") {
+        return { capabilities: ["read"], readOnly: true, sandboxMode: "read-only" };
+    }
+    if (risk === "write") {
+        return {
+            capabilities: ["write", "patch"],
+            readOnly: false,
+            sandboxMode: "workspace-write",
+        };
+    }
+    if (risk === "merge") {
+        return {
+            capabilities: ["write", "patch", "shell", "merge"],
+            readOnly: false,
+            sandboxMode: "workspace-write",
+        };
+    }
+    return {
+        capabilities: ["write", "patch", "shell"],
+        readOnly: false,
+        sandboxMode: "workspace-write",
+    };
+}
+function isApiAdvisoryProvider(provider) {
+    return API_ADVISORY_PROVIDERS.has(provider);
+}
+function debloatRiskFromNativeTurnRisk(risk) {
+    if (risk === "read")
+        return "read";
+    if (risk === "write")
+        return "write";
+    return "dangerous";
+}
+export function buildNativeRootLoopTurnNode(input) {
+    const id = input.nodeId ?? `turn-${Date.now()}`;
+    const turnRisk = inferNativeTurnRisk(input.prompt);
+    const routingPolicy = nativeTurnRoutingPolicy(input.bootstrap.provider, turnRisk);
+    const capabilityInjection = buildCapabilityInjection({
+        mcpAllowlist: input.mcpAllowlist,
+        skillNames: input.skillNames,
+        hookNames: input.hookNames,
+    });
+    const envelope = buildPromptEnvelope({
+        bootstrap: input.bootstrap,
+        prompt: input.prompt,
+        capabilities: capabilityInjection,
+        role: "root-coordinator",
+        nodeId: id,
+        executionPrompt: input.executionPrompt,
+        turnRisk,
+        sandboxMode: routingPolicy.sandboxMode,
+    });
+    const rawEnvelope = renderPromptEnvelope(envelope);
+    const compiled = compileBloatToNlp({
+        rawText: rawEnvelope,
+        provider: input.bootstrap.provider,
+        model: input.bootstrap.selectedModel ?? "auto",
+        userPayload: input.prompt,
+        risk: debloatRiskFromNativeTurnRisk(turnRisk),
+        sandbox: routingPolicy.sandboxMode,
+        executionSelection: input.executionPrompt,
+        role: "coordinator",
+        evidenceRequired: false,
+        capabilityEnvelope: {
+            mcpEnabled: capabilityInjection.mcpServers,
+            skillsEnabled: capabilityInjection.skills,
+            toolsEnabled: capabilityInjection.tools.length > 0,
+            liveRequired: capabilityInjection.requiresMcp,
+        },
+    });
+    const selectedMcp = [
+        ...compiled.runtimeSidecar.requiredMcp,
+        ...compiled.runtimeSidecar.optionalMcp,
+    ];
+    const selectedCapabilityInjection = buildCapabilityInjection({
+        mcpAllowlist: selectedMcp,
+        skillNames: compiled.runtimeSidecar.selectedSkills,
+        hookNames: input.hookNames,
+        tools: capabilityInjection.tools,
+        requireMcp: !isApiAdvisoryProvider(input.bootstrap.provider)
+            && compiled.runtimeSidecar.requiredMcp.length > 0,
+        requiresToolCalling: capabilityInjection.requiresToolCalling,
+    });
+    return {
+        id,
+        name: compiled.modelPrompt,
+        role: "coordinator",
+        dependsOn: [],
+        status: "running",
+        retries: 0,
+        maxRetries: 1,
+        routing: applyCapabilityInjectionToRouting({
+            provider: input.bootstrap.provider,
+            providerModel: input.bootstrap.selectedModel,
+            providerReason: `native-root-loop selected ${input.bootstrap.selectedRuntimeId ?? input.bootstrap.sessionMode}${routingPolicy.providerReasonSuffix ?? ""}`,
+            assignedProviderCapabilities: routingPolicy.capabilities,
+            contextBudget: "normal",
+            readOnly: routingPolicy.readOnly,
+            risk: turnRisk,
+            promptMode: "dnc-nlp",
+            runtimeSidecar: {
+                ...compiled.runtimeSidecar,
+                requiredMcp: [...compiled.runtimeSidecar.requiredMcp],
+                optionalMcp: [...compiled.runtimeSidecar.optionalMcp],
+                disabledMcp: [...compiled.runtimeSidecar.disabledMcp],
+                selectedSkills: [...compiled.runtimeSidecar.selectedSkills],
+            },
+            executionPrompt: input.executionPrompt,
+            approvalPolicy: input.executionPrompt,
+            sandboxMode: routingPolicy.sandboxMode,
+            rationale: `native-root-loop DNC intent=${compiled.runtimeSidecar.intent}; selected MCP=${selectedMcp.length}; selected skills=${compiled.runtimeSidecar.selectedSkills.length}; optional failures follow required-only policy`,
+        }, selectedCapabilityInjection),
+    };
+}
+function runtimeSidecarIntent(node) {
+    const sidecar = node.routing?.runtimeSidecar;
+    if (!sidecar || typeof sidecar !== "object")
+        return undefined;
+    const intent = sidecar.intent;
+    return typeof intent === "string" && intent.trim().length > 0 ? intent : undefined;
+}
+function describeNativeTurnActivity(node) {
+    const intent = runtimeSidecarIntent(node);
+    const risk = node.routing?.risk;
+    const provider = node.routing?.provider ?? "auto";
+    const mcpCount = node.routing?.mcpServers?.length ?? 0;
+    const skillCount = node.routing?.skills?.length ?? 0;
+    const intentPart = intent ? intent.replace(/_/g, " ") : "agent turn";
+    const guardPart = risk && risk !== "read" ? `${risk} gate` : "evidence gate";
+    const scopePart = mcpCount > 0 || skillCount > 0
+        ? `${mcpCount} MCP/${skillCount} skills`
+        : "local ctx";
+    return `${intentPart} · ${guardPart} · ${scopePart} · ${provider}`;
+}
+async function executeNativeRootTurn(input) {
+    const startedAt = Date.now();
+    const routing = input.node.routing;
+    const activity = describeNativeTurnActivity(input.node);
+    emitNativeTurnRoute(input);
+    recordNativeTurnToolAuthority({ node: input.node, env: input.env, renderer: input.renderer });
+    let heartbeatPrinted = false;
+    let heartbeatLineClosed = false;
+    const heartbeat = input.heartbeatEnabled
+        ? setInterval(() => {
+            heartbeatPrinted = true;
+            const sec = Math.floor((Date.now() - startedAt) / 1000);
+            if (input.renderer) {
+                input.renderer.emit({
+                    type: "turn:heartbeat",
+                    elapsedMs: sec * 1000,
+                    provider: routing?.provider ?? "auto",
+                    model: routing?.providerModel ?? input.env.OMK_PROVIDER_MODEL,
+                    activity,
+                });
+            }
+            else {
+                process.stderr.write(style.phosphorDim(`\r  ${activity} · ${sec}s · model=${routing?.providerModel ?? input.env.OMK_PROVIDER_MODEL ?? "auto"}   `));
+            }
+        }, 3000)
+        : undefined;
+    heartbeat?.unref?.();
+    try {
+        const result = await input.taskRunner.run(input.node, input.env, input.signal, input.runContext);
+        if (input.heartbeatEnabled) {
+            const sec = ((Date.now() - startedAt) / 1000).toFixed(1);
+            if (input.renderer) {
+                heartbeatLineClosed = true;
+            }
+            else {
+                if (heartbeatPrinted) {
+                    process.stderr.write("\n");
+                    heartbeatLineClosed = true;
+                }
+                process.stderr.write(style.phosphorDim(`  finished in ${sec}s · exit=${result.exitCode}\n`));
+            }
+        }
+        return result;
+    }
+    finally {
+        if (heartbeat)
+            clearInterval(heartbeat);
+        if (heartbeatPrinted && !heartbeatLineClosed && !input.renderer)
+            process.stderr.write("\n");
+    }
+}
+async function buildNativeRootLoopTurnDag(input) {
+    const dag = await buildChatTurnDag({
+        prompt: input.prompt,
+        runId: "native-chat-turn",
+        providerPolicy: bootstrapProviderPolicy(input.bootstrap),
+        providerModel: input.bootstrap.selectedModel,
+        workerCount: input.workers,
+        executionStrategy: nativeExecutionStrategy(input.executionPrompt),
+        mcpAllowlist: input.mcpAllowlist,
+        skillNames: input.skillNames,
+        hookNames: input.hookNames,
+    });
+    if (dag.nodes.length !== 1)
+        return dag;
+    const node = buildNativeRootLoopTurnNode({
+        bootstrap: input.bootstrap,
+        prompt: input.prompt,
+        nodeId: dag.nodes[0]?.id,
+        mcpAllowlist: input.mcpAllowlist,
+        skillNames: input.skillNames,
+        hookNames: input.hookNames,
+        executionPrompt: input.executionPrompt,
+    });
+    return createDag({ nodes: [node] });
+}
+function combineNativeHarnessResults(success, completed) {
+    const last = completed.at(-1)?.result;
+    const stdout = completed
+        .map(({ result }) => result.stdout)
+        .filter((text) => Boolean(text))
+        .join("\n\n");
+    const stderr = completed
+        .map(({ result }) => result.stderr)
+        .filter((text) => Boolean(text))
+        .join("\n");
+    return {
+        success,
+        exitCode: success ? 0 : (last?.exitCode ?? 1),
+        stdout,
+        stderr,
+        metadata: {
+            ...(last?.metadata ?? {}),
+            harness: "dag-executor",
+            completedNodes: completed.length,
+        },
+    };
+}
+async function executeNativeRootHarnessTurn(input) {
+    const dag = await buildNativeRootLoopTurnDag({
+        bootstrap: input.bootstrap,
+        prompt: input.prompt,
+        mcpAllowlist: input.mcpAllowlist,
+        skillNames: input.skillNames,
+        hookNames: input.hookNames,
+        executionPrompt: input.executionPrompt,
+        workers: input.workers,
+    });
+    const completed = [];
+    const workerCount = Math.max(1, input.workers ?? 1);
+    const executionStrategy = nativeExecutionStrategy(input.executionPrompt) ?? "sequential";
+    if (input.inputEnvelope) {
+        await persistNativeDagCompileArtifacts({
+            envelope: input.inputEnvelope,
+            dag,
+            root: input.root,
+            workerCount,
+            executionStrategy,
+            explanation: "native chat turn compiled for shared harness execution",
+            renderer: input.renderer,
+        });
+    }
+    const run = await executeHarnessRun({
+        root: input.root,
+        runId: input.runId,
+        dag,
+        runner: input.taskRunner,
+        env: input.env,
+        workers: workerCount,
+        approvalPolicy: nativeApprovalPolicy(input.executionPrompt),
+        signal: input.signal,
+        onNodeStart: (node) => {
+            emitNativeTurnRoute({
+                node,
+                env: input.env,
+                heartbeatEnabled: input.heartbeatEnabled,
+                renderer: input.renderer,
+                mcpAllowlist: node.routing?.mcpServers ?? input.mcpAllowlist,
+                skillNames: node.routing?.skills ?? input.skillNames,
+                hookNames: node.routing?.hooks ?? input.hookNames,
+            });
+            recordNativeTurnToolAuthority({ node, env: input.env, renderer: input.renderer });
+        },
+        onNodeComplete: (node, result) => {
+            completed.push({ node, result });
+        },
+    });
+    const result = combineNativeHarnessResults(run.success, completed);
+    result.metadata = {
+        ...(result.metadata ?? {}),
+        runId: run.state.runId,
+        nodeCount: run.state.nodes.length,
+        failedNodes: run.state.nodes.filter((node) => node.status === "failed" || node.status === "blocked").length,
+    };
+    return result;
+}
+export async function runNativeOmkRootLoop(input) {
+    const { taskRunner, layout, onData } = input;
+    const renderer = input.renderer;
+    const turnTimeoutMs = Number.parseInt(input.env.OMK_TURN_TIMEOUT_MS ?? "120000", 10);
+    const safeTurnTimeoutMs = Number.isFinite(turnTimeoutMs) && turnTimeoutMs > 0
+        ? turnTimeoutMs
+        : 120_000;
+    const state = createNativeRootSessionState({
+        bootstrap: input.bootstrap,
+        executionPrompt: input.executionPrompt,
+    });
+    const slashRegistry = createSlashCommandRegistry(buildNativeChatSlashCommands());
+    const slashContext = createSlashCommandContext(input, state, {
+        runParallelTurn: (prompt, activeRenderer) => runNativeParallelTurn(input, prompt, activeRenderer),
+    });
+    await renderer?.start();
+    renderer?.emit({
+        type: "session:start",
+        runId: input.runId,
+        provider: state.provider,
+        model: state.model,
+        layout,
+        root: input.root,
+        cwd: input.activeCwd,
+        rootSource: input.rootSource,
+        brandLabel: input.env.OMK_ENTRY_DISPLAY_NAME,
+    });
+    // opencode-style: banner handled by PlainModernRenderer session:start event
+    const modelProviderRegistry = await readProviderRegistry({ env: input.env }).catch(() => []);
+    const modelProviderIds = modelProviderRegistry.map((entry) => entry.id);
+    const modelPickerState = createModelPickerState(ALL_PROVIDER_TAB);
+    const renderModelPicker = (key, previousActiveProviderTab) => {
+        const tabs = buildProviderTabs(modelProviderIds);
+        const activeProviderTab = normalizeProviderTab(modelPickerState.activeProviderTab, tabs);
+        debugModelTabs({
+            providerIds: modelProviderIds,
+            tabs,
+            activeProviderTab: previousActiveProviderTab ?? activeProviderTab,
+            key,
+            nextProviderTab: previousActiveProviderTab ? activeProviderTab : undefined,
+            runtimeProvider: state.provider,
+            runtimeModel: state.model,
+            visibleRowCount: countModelPickerRows(modelProviderRegistry, activeProviderTab),
+        });
+        const text = renderProviderModelTable(modelProviderRegistry, {
+            currentProvider: state.provider,
+            currentModel: state.model,
+            currentThinking: state.thinking,
+            activeProviderTab,
+        });
+        if (renderer)
+            renderer.emit({ type: "control:output", text });
+        else
+            process.stdout.write(`${text}\n`);
+    };
+    const renderThinkingPicker = () => {
+        const text = renderThinkingPickerText(state);
+        if (renderer)
+            renderer.emit({ type: "control:output", text });
+        else
+            process.stdout.write(`${text}\n`);
+    };
+    // Defensive stdin re-validation before the chat readline takes ownership.
+    // The first-run GitHub-star / update prompts (@inquirer/prompts) can take
+    // over raw mode and leave the shared interactive stdin paused; a paused TTY
+    // makes the readline below see an immediate EOF/'close' and exit the loop
+    // with "Session ended". This only resumes an explicitly-paused TTY and never
+    // touches non-TTY stdin (its EOF/exit behavior must stay unchanged).
+    resumeInteractiveInput(process.stdin);
+    const { createInterface } = await import("readline");
+    const rl = createInterface({
+        input: process.stdin,
+        output: renderer ? process.stderr : process.stdout,
+        completer: (line) => {
+            if (isModelPickerLine(line, state)) {
+                const previousActiveProviderTab = modelPickerState.activeProviderTab;
+                const explicitProviderTab = explicitProviderTabFromModelLine(line, modelProviderIds);
+                const isFreshQuery = modelPickerState.query !== line;
+                if (isFreshQuery) {
+                    initializeModelPickerState({
+                        state: modelPickerState,
+                        providerIds: modelProviderIds,
+                        explicitProviderTab,
+                    });
+                    state.modelPickerOpen = true;
+                    state.thinkingPickerOpen = false;
+                    state.activeProviderTab = modelPickerState.activeProviderTab;
+                    modelPickerState.query = line;
+                    renderModelPicker(explicitProviderTab ? "/model explicit" : "/model");
+                }
+                else if (handleModelPickerKey({
+                    key: "\t",
+                    state: modelPickerState,
+                    providerIds: modelProviderIds,
+                })) {
+                    state.modelPickerOpen = true;
+                    state.thinkingPickerOpen = false;
+                    state.activeProviderTab = modelPickerState.activeProviderTab;
+                    modelPickerState.query = line;
+                    renderModelPicker("\t", previousActiveProviderTab);
+                }
+                return [[], line];
+            }
+            if (/^\/(?:think|thinking)\s*$/.test(line.trim()) && state.thinkingPickerOpen !== true) {
+                state.thinkingPickerOpen = true;
+                state.modelPickerOpen = false;
+                renderThinkingPicker();
+                return [[], line];
+            }
+            if (isThinkingPickerLine(line, state)) {
+                const next = nextThinkingLevel(state.thinking ?? input.env.OMK_THINKING, state.provider, state.model);
+                state.thinking = next;
+                state.thinkingPickerOpen = true;
+                state.modelPickerOpen = false;
+                state.updatedAt = new Date().toISOString();
+                input.env.OMK_THINKING = next;
+                input.env.OMK_MODEL_VARIANT = formatThinkingModelVariant(state.model, next);
+                renderThinkingPicker();
+            }
+            return [[], line];
+        },
+    });
+    const modelPickerRawKeyHandler = (chunk) => {
+        const key = Buffer.isBuffer(chunk) ? chunk.toString("utf8") : chunk;
+        if (key !== "\x1b[Z" || state.modelPickerOpen !== true) {
+            return;
+        }
+        const previousActiveProviderTab = modelPickerState.activeProviderTab;
+        if (handleModelPickerKey({ key, state: modelPickerState, providerIds: modelProviderIds })) {
+            state.activeProviderTab = modelPickerState.activeProviderTab;
+            renderModelPicker(key, previousActiveProviderTab);
+        }
+    };
+    process.stdin.on("data", modelPickerRawKeyHandler);
+    const terminalOwner = new TerminalOwner(process.stdin);
+    const releaseReadlineOwner = terminalOwner.claimReadline();
+    let running = true;
+    let readlineClosed = false;
+    let activeTurnAbort;
+    let pendingPastedImageLine;
+    const queuedLines = [];
+    let pendingLineResolve;
+    const resolveNextLine = (value) => {
+        const resolve = pendingLineResolve;
+        pendingLineResolve = undefined;
+        resolve?.(value);
+    };
+    rl.on("line", (line) => {
+        rl.pause();
+        if (pendingLineResolve) {
+            resolveNextLine(line);
+        }
+        else {
+            queuedLines.push(line);
+        }
+    });
+    rl.once("close", () => {
+        process.stdin.off("data", modelPickerRawKeyHandler);
+        readlineClosed = true;
+        if (queuedLines.length === 0)
+            resolveNextLine(undefined);
+    });
+    const onSigint = () => {
+        if (activeTurnAbort && !activeTurnAbort.signal.aborted) {
+            activeTurnAbort.abort();
+            process.stderr.write(style.phosphorDim("\nTurn cancelled. Press Ctrl+C again to exit.\n"));
+            return;
+        }
+        running = false;
+        rl.close();
+    };
+    process.on("SIGINT", onSigint);
+    const readPromptLine = async () => {
+        if (readlineClosed && queuedLines.length === 0)
+            return undefined;
+        if (renderer) {
+            renderer.emit({ type: "prompt:ready" });
+        }
+        else {
+            process.stdout.write(style.phosphorDim("omk> "));
+        }
+        const queued = queuedLines.shift();
+        if (queued !== undefined)
+            return queued;
+        rl.resume();
+        return new Promise((resolve) => {
+            pendingLineResolve = resolve;
+            if (readlineClosed)
+                resolveNextLine(undefined);
+        });
+    };
+    while (running) {
+        const userInput = await readPromptLine();
+        if (userInput === undefined)
+            break;
+        let line = userInput.trim();
+        if (!line)
+            continue;
+        renderer?.emit({ type: "input:submitted", text: line });
+        if (["exit", "quit", ":q", "/exit", "/quit"].includes(line.toLowerCase())) {
+            running = false;
+            break;
+        }
+        const parsedSlash = parseSlashInput(line);
+        if (!parsedSlash && pendingPastedImageLine) {
+            line = `${pendingPastedImageLine}\n${line}`;
+            pendingPastedImageLine = undefined;
+        }
+        const inputEnvelope = buildNativeInputEnvelope({
+            loopInput: input,
+            state,
+            line,
+            parsedSlash,
+        });
+        await persistNativeInputEnvelope({
+            envelope: inputEnvelope,
+            root: input.root,
+            renderer,
+        });
+        if (parsedSlash) {
+            const handler = slashRegistry.resolve(parsedSlash);
+            if (handler) {
+                const modelShow = isModelShowSlash(parsedSlash);
+                if (modelShow) {
+                    initializeModelPickerState({
+                        state: modelPickerState,
+                        providerIds: modelProviderIds,
+                    });
+                    modelPickerState.query = "";
+                    state.modelPickerOpen = true;
+                    state.thinkingPickerOpen = false;
+                    state.activeProviderTab = modelPickerState.activeProviderTab;
+                    const tabs = buildProviderTabs(modelProviderIds);
+                    debugModelTabs({
+                        providerIds: modelProviderIds,
+                        tabs,
+                        activeProviderTab: ALL_PROVIDER_TAB,
+                        key: "/model",
+                        runtimeProvider: state.provider,
+                        runtimeModel: state.model,
+                        visibleRowCount: countModelPickerRows(modelProviderRegistry, ALL_PROVIDER_TAB),
+                    });
+                }
+                else if (isModelSlashCommand(parsedSlash)) {
+                    state.modelPickerOpen = false;
+                    state.activeProviderTab = ALL_PROVIDER_TAB;
+                }
+                try {
+                    let slashResult;
+                    const thinkingShow = isThinkingShowSlash(parsedSlash);
+                    const interactiveThinkingSelector = canUseInteractiveThinkingSelector(input, renderer);
+                    await terminalOwner.withChildProcess(rl, async () => {
+                        const result = await runSlashHandler(handler, parsedSlash, slashContext, { suppressOutput: thinkingShow && interactiveThinkingSelector });
+                        slashResult = result;
+                        if (parsedSlash.command === "/paste" && result.ok) {
+                            const pasteLine = result.text?.trim();
+                            if (pasteLine) {
+                                pendingPastedImageLine = pendingPastedImageLine
+                                    ? `${pendingPastedImageLine}\n${pasteLine}`
+                                    : pasteLine;
+                            }
+                        }
+                        if (result.exit)
+                            running = false;
+                    });
+                    const shouldSelectThinking = slashResult
+                        ? (thinkingShow && interactiveThinkingSelector) || shouldOpenThinkingPickerAfterSlash(parsedSlash, slashResult)
+                        : false;
+                    if (shouldSelectThinking) {
+                        state.modelPickerOpen = false;
+                        state.thinkingPickerOpen = true;
+                        state.activeProviderTab = ALL_PROVIDER_TAB;
+                        const selected = await terminalOwner.withRawSelector(rl, () => promptThinkingSelection(input, state, renderer));
+                        if (!selected)
+                            renderThinkingPicker();
+                    }
+                    else if (isThinkingSlashCommand(parsedSlash)) {
+                        state.modelPickerOpen = false;
+                        state.thinkingPickerOpen = true;
+                    }
+                    else if (!modelShow && isThinkingFollowupSlash(parsedSlash)) {
+                        state.modelPickerOpen = false;
+                        state.thinkingPickerOpen = false;
+                    }
+                    else if (!modelShow && !isModelSlashCommand(parsedSlash)) {
+                        state.modelPickerOpen = false;
+                        state.thinkingPickerOpen = false;
+                    }
+                }
+                catch (err) {
+                    const m = err instanceof Error ? err.message : String(err);
+                    if (renderer) {
+                        renderer.emit({
+                            type: "turn:error",
+                            message: `Command error: ${m}`,
+                        });
+                    }
+                    else {
+                        console.error(style.metricsRed(`Command error: ${m}`));
+                    }
+                }
+                continue;
+            }
+            state.modelPickerOpen = false;
+            state.thinkingPickerOpen = false;
+            const message = `Unknown command: ${parsedSlash.command}. Type /help for commands.`;
+            if (renderer) {
+                renderer.emit({ type: "turn:error", message });
+            }
+            else {
+                console.log(style.phosphorDim(message));
+            }
+            continue;
+        }
+        state.modelPickerOpen = false;
+        state.thinkingPickerOpen = false;
+        if (shouldRunNativeParallelTurn(state.approvalPolicy)) {
+            const turnStartedAt = Date.now();
+            try {
+                const exitCode = await terminalOwner.withChildProcess(rl, () => runNativeParallelTurn(input, line, renderer));
+                renderer?.emit({
+                    type: "turn:finish",
+                    durationMs: Date.now() - turnStartedAt,
+                    exitCode,
+                });
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                if (renderer) {
+                    renderer.emit({ type: "turn:error", message: msg });
+                }
+                else {
+                    console.error(style.metricsRed(`Error: ${msg}`));
+                }
+            }
+            continue;
+        }
+        const abort = new AbortController();
+        activeTurnAbort = abort;
+        const timeout = setTimeout(() => abort.abort(), safeTurnTimeoutMs);
+        try {
+            const turnStartedAt = Date.now();
+            let result;
+            if (isDisabledEnvValue(input.env.OMK_CHAT_HARNESS_TURN)) {
+                const node = buildNativeRootLoopTurnNode({
+                    bootstrap: state.bootstrap,
+                    prompt: line,
+                    mcpAllowlist: input.mcpAllowlist,
+                    skillNames: input.skillNames,
+                    hookNames: input.hookNames,
+                    executionPrompt: state.approvalPolicy,
+                });
+                await persistNativeDagCompileArtifacts({
+                    envelope: inputEnvelope,
+                    dag: { nodes: [node] },
+                    root: input.root,
+                    workerCount: 1,
+                    executionStrategy: nativeExecutionStrategy(state.approvalPolicy) ?? "sequential",
+                    explanation: "native direct chat turn compiled to a single-node DAG artifact",
+                    renderer,
+                });
+                const turnMcpAllowlist = node.routing?.mcpServers ?? input.mcpAllowlist;
+                const turnSkillNames = node.routing?.skills ?? input.skillNames;
+                const turnHookNames = node.routing?.hooks ?? input.hookNames;
+                const runContext = buildTaskRunContext({
+                    runId: input.runId,
+                    root: input.root,
+                    node,
+                    objective: line,
+                    toolPlane: {
+                        mcpServers: turnMcpAllowlist,
+                        mcpConfigFile: input.env.OMK_MCP_CONFIG_FILE,
+                        skills: turnSkillNames,
+                        hooks: turnHookNames,
+                        tools: node.routing?.tools,
+                        requiresRuntimeMcp: node.routing?.requiresMcp,
+                    },
+                    selectedRuntimeId: state.bootstrap.selectedRuntimeId,
+                    model: state.bootstrap.selectedModel,
+                });
+                result = await terminalOwner.withChildProcess(rl, () => executeNativeRootTurn({
+                    taskRunner,
+                    node,
+                    env: input.env,
+                    signal: abort.signal,
+                    heartbeatEnabled: !isDisabledEnvValue(input.env.OMK_TURN_HEARTBEAT),
+                    renderer,
+                    mcpAllowlist: turnMcpAllowlist,
+                    skillNames: turnSkillNames,
+                    hookNames: turnHookNames,
+                    runContext,
+                }));
+            }
+            else {
+                result = await terminalOwner.withChildProcess(rl, () => executeNativeRootHarnessTurn({
+                    taskRunner,
+                    bootstrap: state.bootstrap,
+                    prompt: line,
+                    runId: input.runId,
+                    root: input.root,
+                    env: input.env,
+                    signal: abort.signal,
+                    heartbeatEnabled: !isDisabledEnvValue(input.env.OMK_TURN_HEARTBEAT),
+                    renderer,
+                    mcpAllowlist: input.mcpAllowlist,
+                    skillNames: input.skillNames,
+                    hookNames: input.hookNames,
+                    workers: input.workers,
+                    executionPrompt: state.approvalPolicy,
+                    inputEnvelope,
+                }));
+            }
+            if (result.stdout) {
+                if (renderer) {
+                    renderer.emit({ type: "assistant:final", text: result.stdout });
+                }
+                else {
+                    const toolSummary = result.metadata?.harness === "dag-executor"
+                        ? `dag ${String(result.metadata.nodeCount ?? 1)} nodes`
+                        : "native turn";
+                    process.stdout.write(style.phosphorDim(`\n  ✓ Done · ${toolSummary}\n`));
+                }
+                onData?.(result.stdout);
+            }
+            if (result.stderr && result.exitCode !== 0) {
+                if (renderer) {
+                    renderer.emit({ type: "turn:error", message: result.stderr });
+                }
+                else {
+                    process.stderr.write(style.metricsRed(result.stderr) + "\n");
+                }
+            }
+            if (!result.stdout && result.exitCode !== 0) {
+                const metaError = result.metadata &&
+                    typeof result.metadata === "object" &&
+                    "error" in result.metadata
+                    ? String(result.metadata.error)
+                    : undefined;
+                const message = metaError
+                    ? `Turn exited with code ${result.exitCode}: ${metaError}`
+                    : `Turn exited with code ${result.exitCode}`;
+                if (renderer) {
+                    renderer.emit({ type: "turn:error", message });
+                }
+                else {
+                    process.stderr.write(style.metricsRed(message) + "\n");
+                }
+            }
+            if (input.onTodoSync && result.stdout) {
+                input.onTodoSync(result.stdout);
+            }
+            renderer?.emit({
+                type: "turn:finish",
+                durationMs: Date.now() - turnStartedAt,
+                exitCode: result.exitCode ?? 0,
+            });
+        }
+        catch (err) {
+            const msg = abort.signal.aborted
+                ? `Turn timed out after ${safeTurnTimeoutMs}ms`
+                : err instanceof Error
+                    ? err.message
+                    : String(err);
+            if (renderer) {
+                renderer.emit({ type: "turn:error", message: msg });
+            }
+            else {
+                console.error(style.metricsRed(`Error: ${msg}`));
+            }
+        }
+        finally {
+            activeTurnAbort = undefined;
+            clearTimeout(timeout);
+        }
+    }
+    process.off("SIGINT", onSigint);
+    releaseReadlineOwner();
+    if (!readlineClosed)
+        rl.close();
+    if (renderer) {
+        renderer.emit({ type: "session:stop", exitCode: 0 });
+        await renderer.stop();
+    }
+    else {
+        console.log(style.phosphorDim(`\n  Session ended. Run ${style.cream("omk runs")} to see history.\n`));
+    }
+    return 0;
+}