open-multi-agent-kit 0.80.2 → 0.80.3

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

@@ -1,1584 +0,0 @@
-import { style } from "../../util/theme.js";
-import { getRunArtifactPath } from "../../util/run-store.js";
-import { runShell } from "../../util/shell.js";
-import { mkdir, writeFile, appendFile, readFile } from "node:fs/promises";
-import { mkdirSync, writeFileSync } from "node:fs";
-import { createHash } from "node:crypto";
-import { dirname } from "node:path";
-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 { resolveToolAuthorityMode } 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 { evidenceObservationsFromResult, evidenceRequirementsFromOutputs } from "../../runtime/contracts/evidence.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";
-import { LocalGraphMemoryStore } from "../../memory/local-graph-memory-store.js";
-import { runtimeIsAdvisory } from "../../runtime/authority-matrix.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";
-    }
-}
-/**
- * Turn-level tool-authority checkpoint. Shadow mode records only when tracing is
- * enabled, warn mode emits a diagnostic, and enforce mode fail-closes block/ask
- * verdicts before dispatching the native turn.
- */
-function recordNativeTurnToolAuthority(input) {
-    const routing = input.node.routing;
-    const scopes = capabilityScopesFromRouting(routing);
-    const op = nativeTurnRiskToToolOp(routing?.risk);
-    const mode = resolveToolAuthorityMode(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 enforced = mode === "enforce" && decision !== "allow";
-    const reason = `tool-authority ${decision} for ${op} op ` +
-        `(write=${scopes.writeAuthority}, shell=${scopes.shellAuthority}, ` +
-        `sandbox=${routing?.sandboxMode ?? "auto"}, mode=${mode})`;
-    const traceEnabled = mode !== "shadow" ||
-        input.env.OMK_DEBUG === "1" ||
-        /^(1|true|yes|on)$/i.test(input.env.OMK_TOOL_AUTHORITY_TRACE ?? "");
-    if (traceEnabled) {
-        const line = `  ${reason}${enforced ? " [enforced]" : ""}\n`;
-        if (input.renderer) {
-            input.renderer.emit({ type: "control:output", text: style.phosphorDim(line) });
-        }
-        else {
-            process.stderr.write(style.phosphorDim(line));
-        }
-    }
-    return { mode, op, decision, enforced, reason };
-}
-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");
-    }
-}
-function hasExplicitReadOnlyConstraint(text) {
-    return (/\b(without changing|without editing|do not change|don't change|do not edit|don't edit|no edits?|no file changes?|read[- ]only)\b/.test(text) ||
-        /읽기\s*전용|수정하지\s*말|변경하지\s*말|파일\s*(수정|변경)\s*(없이|하지\s*말)|검토만|분석만/.test(text));
-}
-function hasReadOnlyIntent(text) {
-    return (/\b(read|inspect|look|show|list|summarize|explain|describe|review|audit|status|diagnose)\b/.test(text) ||
-        /요약|설명|상태|검토|분석|읽어|살펴/.test(text));
-}
-function detectExcludedOps(text) {
-    const excluded = new Set();
-    const scopes = [];
-    const add = (op, scope) => {
-        excluded.add(op);
-        scopes.push(scope);
-    };
-    const mergeTerms = "push|publish|release|merge|tag|deploy|version|npm publish|릴리즈|머지|배포|태그|푸시|버전|퍼블리시";
-    const shellTerms = "run|test|build|exec|execute|shell|terminal|command|npm|pnpm|yarn|bun|pytest|cargo|tsc|lint|verify|check|테스트|빌드|실행|검증|쉘|터미널|체크|명령";
-    const writeTerms = "fix|edit|write|implement|modify|patch|refactor|add|create|delete|update|change|수정|구현|패치|리팩터|추가|삭제|변경";
-    const englishNegationPrefix = "no|not|without|excluding|exclude|except|skip|skipping|omit|avoid|but not|do not|don't";
-    const englishNegationSuffix = "excluded|excepted|skipped|omitted|disabled|only on explicit request|only when requested";
-    if (new RegExp(`\\b(?:${englishNegationPrefix})\\b.{0,40}\\b(?:${mergeTerms})\\b`, "i").test(text) ||
-        new RegExp(`\\b(?:${mergeTerms})\\b.{0,40}\\b(?:${englishNegationSuffix})\\b`, "i").test(text) ||
-        /(?:릴리즈|머지|배포|태그|푸시|버전|퍼블리시).{0,16}(?:빼고|제외|없이|말고|하지\s*말|금지|명령시(?:에)?만|요청시(?:에)?만)/.test(text) ||
-        /(?:빼고|제외|없이|말고).{0,16}(?:릴리즈|머지|배포|태그|푸시|버전|퍼블리시)/.test(text)) {
-        add("merge", "excluded-merge-scope");
-    }
-    if (new RegExp(`\\b(?:${englishNegationPrefix})\\b.{0,40}\\b(?:${shellTerms})\\b`, "i").test(text) ||
-        new RegExp(`\\b(?:${shellTerms})\\b.{0,40}\\b(?:${englishNegationSuffix})\\b`, "i").test(text) ||
-        /(?:npm|테스트|빌드|실행|검증|체크|명령|쉘|터미널).{0,16}(?:빼고|제외|없이|말고|하지\s*말|금지|명령시(?:에)?만|요청시(?:에)?만)/.test(text) ||
-        /(?:빼고|제외|없이|말고).{0,16}(?:npm|테스트|빌드|실행|검증|체크|명령|쉘|터미널)/.test(text)) {
-        add("shell", "excluded-shell-scope");
-    }
-    if (new RegExp(`\\b(?:${englishNegationPrefix})\\b.{0,40}\\b(?:${writeTerms})\\b`, "i").test(text) ||
-        /(?:수정|구현|패치|리팩터|추가|삭제|변경).{0,16}(?:빼고|제외|없이|말고|하지\s*말|금지)/.test(text)) {
-        add("write", "excluded-write-scope");
-    }
-    return { ops: [...excluded], scopes };
-}
-function nativeRiskTrace(input) {
-    return {
-        risk: input.risk,
-        confidence: input.confidence,
-        matchedSignal: input.matchedSignal,
-        readOnlyOverride: input.readOnlyOverride ?? false,
-        positiveSignals: [...(input.positiveSignals ?? [])],
-        negativeScopes: [...(input.negativeScopes ?? [])],
-        requestedOps: [...(input.requestedOps ?? [])],
-        excludedOps: [...(input.excludedOps ?? [])],
-    };
-}
-export function inferNativeTurnRisk(prompt) {
-    const text = prompt.toLowerCase();
-    const excluded = detectExcludedOps(text);
-    if (hasExplicitReadOnlyConstraint(text)) {
-        return nativeRiskTrace({ risk: "read", confidence: 0.95, matchedSignal: "explicit-read-only-constraint", readOnlyOverride: true, negativeScopes: excluded.scopes, excludedOps: excluded.ops });
-    }
-    const candidates = [
-        { risk: "merge", confidence: 0.9, signal: "merge/release-keyword", pattern: /\b(push|publish|release|merge|tag|deploy)\b|푸시|퍼블리시|릴리즈|머지|배포/ },
-        { risk: "shell", confidence: 0.85, signal: "shell/execution-keyword", pattern: /\b(run|test|build|exec|execute|shell|terminal|command|npm|pnpm|yarn|bun|pytest|cargo|go test|tsc|lint|verify|check)\b|테스트|빌드|실행|검증|쉘|터미널/ },
-        { risk: "write", confidence: 0.85, signal: "write/modify-keyword", pattern: /\b(fix|edit|write|implement|modify|patch|refactor|add|create|delete|update|change)\b|수정|구현|패치|리팩터|추가|삭제|변경/ },
-    ];
-    const positive = candidates.filter((candidate) => candidate.pattern.test(text));
-    const requestedOps = positive.map((candidate) => candidate.risk);
-    const selected = positive.find((candidate) => !excluded.ops.includes(candidate.risk));
-    if (selected) {
-        return nativeRiskTrace({
-            risk: selected.risk,
-            confidence: selected.confidence,
-            matchedSignal: selected.signal,
-            positiveSignals: positive.map((candidate) => candidate.signal),
-            negativeScopes: excluded.scopes,
-            requestedOps,
-            excludedOps: excluded.ops,
-        });
-    }
-    if (positive.length > 0) {
-        const risk = hasReadOnlyIntent(text) ? "read" : "ask";
-        return nativeRiskTrace({
-            risk,
-            confidence: risk === "read" ? 0.75 : 0.55,
-            matchedSignal: `all-positive-risk-signals-excluded:${positive.map((candidate) => candidate.signal).join(",")}`,
-            positiveSignals: positive.map((candidate) => candidate.signal),
-            negativeScopes: excluded.scopes,
-            requestedOps,
-            excludedOps: excluded.ops,
-        });
-    }
-    if (hasReadOnlyIntent(text))
-        return nativeRiskTrace({ risk: "read", confidence: 0.75, matchedSignal: "read-only-intent", negativeScopes: excluded.scopes, excludedOps: excluded.ops });
-    return nativeRiskTrace({ risk: "ask", confidence: 0.5, matchedSignal: "no-clear-signal", negativeScopes: excluded.scopes, excludedOps: excluded.ops });
-}
-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" || risk === "ask") {
-        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 runtimeIsAdvisory({
-        id: `${provider}-api`,
-        providerId: provider,
-        runtimeMode: "api",
-        kind: "api",
-    });
-}
-function hashPrompt(value) {
-    return createHash("sha256").update(value).digest("hex");
-}
-function redactedPromptLabel(prompt) {
-    const compact = prompt.replace(/\s+/g, " ").trim().replace(/(sk-[A-Za-z0-9_-]+|ghp_[A-Za-z0-9_]+|[A-Za-z0-9+/]{32,}=*)/g, "[redacted]");
-    const summary = compact.length > 80 ? `${compact.slice(0, 77)}...` : compact;
-    return summary ? `native turn: ${summary}` : "native turn";
-}
-function writePrivatePromptArtifact(input) {
-    try {
-        const rel = `private/prompts/${sanitizeRunIdForPath(input.nodeId)}.json`;
-        const artifact = getRunArtifactPath(input.runId, rel);
-        mkdirSync(dirname(artifact), { recursive: true });
-        writeFileSync(artifact, JSON.stringify({
-            schemaVersion: "omk.prompt-envelope.v1",
-            nodeId: input.nodeId,
-            runId: input.runId,
-            promptHash: input.promptHash,
-            userPrompt: input.userPrompt,
-            compiledPrompt: input.compiledPrompt,
-            redaction: "private-run-artifact",
-            timestamp: new Date().toISOString(),
-        }, null, 2), "utf-8");
-        return rel;
-    }
-    catch {
-        return undefined;
-    }
-}
-function debloatRiskFromNativeTurnRisk(risk) {
-    if (risk === "read" || risk === "ask")
-        return "read";
-    if (risk === "write")
-        return "write";
-    return "dangerous";
-}
-function isStrictGuardrailMode() {
-    const raw = process.env.OMK_STRICT_GUARDRAIL ?? "";
-    const normalized = raw.trim().toLowerCase();
-    return normalized === "1" || normalized === "true" || normalized === "on";
-}
-function nativeTurnRequiresEvidence(risk) {
-    if (isStrictGuardrailMode())
-        return risk === "write" || risk === "shell" || risk === "merge";
-    return false;
-}
-function nativeEvidenceOutputForRisk(risk) {
-    if (!nativeTurnRequiresEvidence(risk))
-        return undefined;
-    if (risk === "shell") {
-        return [{ name: "command evidence", gate: "command-pass", required: true }];
-    }
-    if (risk === "merge") {
-        return [{ name: "release evidence", ref: "## Evidence", gate: "summary", required: true }];
-    }
-    return [{ name: "change evidence", ref: "## Evidence", gate: "summary", required: true }];
-}
-export function buildNativeRootLoopTurnNode(input) {
-    const id = input.nodeId ?? `turn-${Date.now()}`;
-    const riskTrace = inferNativeTurnRisk(input.prompt);
-    let turnRisk = riskTrace.risk;
-    // Low-confidence prompts fall back to ask/read-only to preserve safety.
-    if (riskTrace.confidence < 0.6 && turnRisk !== "read") {
-        turnRisk = "ask";
-    }
-    const evidenceRequired = nativeTurnRequiresEvidence(turnRisk);
-    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,
-        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,
-    });
-    const promptHash = hashPrompt(compiled.modelPrompt);
-    const promptPayloadRef = input.runId
-        ? writePrivatePromptArtifact({ runId: input.runId, nodeId: id, promptHash, userPrompt: input.prompt, compiledPrompt: compiled.modelPrompt })
-        : undefined;
-    return {
-        id,
-        name: redactedPromptLabel(input.prompt),
-        role: "coordinator",
-        dependsOn: [],
-        status: "running",
-        retries: 0,
-        maxRetries: 1,
-        outputs: nativeEvidenceOutputForRisk(turnRisk),
-        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,
-            riskTrace,
-            evidenceRequired,
-            promptMode: promptPayloadRef ? "structured-private" : "dnc-nlp",
-            promptHash,
-            ...(promptPayloadRef && { promptPayloadRef, promptPayloadPrivate: true }),
-            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),
-    };
-}
-async function writeTurnRoutingArtifact(runId, node, runContext) {
-    const artifact = getRunArtifactPath(runId, `turns/${sanitizeRunIdForPath(node.id)}-routing.json`);
-    const payload = {
-        schemaVersion: "omk.native-turn.routing.v1",
-        nodeId: node.id,
-        runId,
-        workerRunId: runContext?.runId,
-        workerOwner: runContext?.worker?.owner,
-        routing: node.routing,
-        outputs: node.outputs,
-        timestamp: new Date().toISOString(),
-    };
-    try {
-        await mkdir(dirname(artifact), { recursive: true });
-        await writeFile(artifact, JSON.stringify(payload, null, 2), "utf-8");
-        return undefined;
-    }
-    catch (err) {
-        // Non-fatal: artifact write failures must not block turn execution, but must be observable.
-        return { error: err instanceof Error ? err.message : String(err) };
-    }
-}
-async function appendTurnResultArtifact(runId, node, result) {
-    const artifact = getRunArtifactPath(runId, `turns/${sanitizeRunIdForPath(node.id)}-result.jsonl`);
-    const payload = {
-        schemaVersion: "omk.native-turn.result.v1",
-        nodeId: node.id,
-        runId,
-        exitCode: result.exitCode,
-        success: result.success,
-        evidenceRequired: result.metadata?.evidenceRequired,
-        timestamp: new Date().toISOString(),
-    };
-    try {
-        await mkdir(dirname(artifact), { recursive: true });
-        await appendFile(artifact, `${JSON.stringify(payload)}\n`, "utf-8");
-        return { artifact };
-    }
-    catch (err) {
-        // Non-fatal: artifact write failures must not block turn execution, but must be observable.
-        return { error: err instanceof Error ? err.message : String(err) };
-    }
-}
-function sanitizeRunIdForPath(value) {
-    return value.replace(/[^A-Za-z0-9._-]/g, "-").slice(0, 64);
-}
-async function sha256File(path) {
-    try {
-        return createHash("sha256").update(await readFile(path)).digest("hex");
-    }
-    catch {
-        return undefined;
-    }
-}
-function parseReplayIndex(raw, runId) {
-    try {
-        const parsed = JSON.parse(raw);
-        if (parsed.schemaVersion !== "omk.replay-index.v1" || parsed.runId !== runId || !Array.isArray(parsed.artifacts)) {
-            throw new Error("invalid replay index");
-        }
-        return {
-            schemaVersion: "omk.replay-index.v1",
-            runId,
-            updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : new Date().toISOString(),
-            artifacts: parsed.artifacts.filter((artifact) => Boolean(artifact && typeof artifact.path === "string" && typeof artifact.kind === "string")),
-        };
-    }
-    catch {
-        return { schemaVersion: "omk.replay-index.v1", runId, updatedAt: new Date().toISOString(), artifacts: [] };
-    }
-}
-async function upsertReplayIndexArtifact(input) {
-    const now = new Date().toISOString();
-    let existing = { schemaVersion: "omk.replay-index.v1", runId: input.runId, updatedAt: now, artifacts: [] };
-    try {
-        existing = parseReplayIndex(await readFile(input.replayIndexPath, "utf-8"), input.runId);
-    }
-    catch {
-        // Missing replay index is expected for the first turn.
-    }
-    const artifacts = existing.artifacts.filter((artifact) => artifact.path !== input.artifactPath);
-    artifacts.push({ path: input.artifactPath, sha256: input.artifactHash, kind: input.artifactKind, updatedAt: now });
-    await writeFile(input.replayIndexPath, JSON.stringify({
-        schemaVersion: "omk.replay-index.v1",
-        runId: input.runId,
-        updatedAt: now,
-        artifacts,
-    }, null, 2), "utf-8");
-}
-async function recordTurnAuditGraph(input) {
-    try {
-        const artifactHash = input.resultArtifact ? await sha256File(input.resultArtifact) : undefined;
-        const replayIndex = getRunArtifactPath(input.runId, "replay-index.json", input.root);
-        await mkdir(dirname(replayIndex), { recursive: true });
-        if (input.resultArtifact) {
-            await upsertReplayIndexArtifact({
-                replayIndexPath: replayIndex,
-                runId: input.runId,
-                artifactPath: input.resultArtifact,
-                artifactHash,
-                artifactKind: "turn-result",
-            });
-        }
-        const store = await LocalGraphMemoryStore.create({ projectRoot: input.root, sessionId: input.runId, source: "native-root-loop-audit" });
-        await store?.materializeTurnAudit({
-            runId: input.runId,
-            nodeId: input.node.id,
-            provider: String(input.node.routing?.provider ?? "auto"),
-            selectedRuntime: typeof input.result.metadata?.selectedRuntime === "string"
-                ? input.result.metadata.selectedRuntime
-                : typeof input.result.metadata?.runtime === "string"
-                    ? input.result.metadata.runtime
-                    : undefined,
-            fallbackChain: Array.isArray(input.result.metadata?.fallbackChain)
-                ? input.result.metadata.fallbackChain.filter((entry) => typeof entry === "string")
-                : undefined,
-            evidenceKind: input.result.success ? "turn-result-pass" : "turn-result-fail",
-            evidenceArtifactPath: input.resultArtifact,
-            evidenceHash: artifactHash,
-            evidenceRequirements: evidenceRequirementsFromOutputs(input.node.outputs),
-            evidenceObservations: evidenceObservationsFromResult({
-                metadata: input.result.metadata,
-                stdout: input.result.stdout,
-                artifactPaths: input.resultArtifact ? [input.resultArtifact] : [],
-            }),
-        });
-    }
-    catch {
-        // Best-effort audit graph materialization must not block turn completion.
-    }
-}
-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}`;
-}
-export async function executeNativeRootTurn(input) {
-    const startedAt = Date.now();
-    const routing = input.node.routing;
-    const activity = describeNativeTurnActivity(input.node);
-    emitNativeTurnRoute(input);
-    const authorityRecord = recordNativeTurnToolAuthority({ node: input.node, env: input.env, renderer: input.renderer });
-    if (authorityRecord.enforced) {
-        const message = `${authorityRecord.reason}; native turn dispatch blocked`;
-        if (input.renderer) {
-            input.renderer.emit({ type: "turn:error", message });
-        }
-        else {
-            process.stderr.write(style.metricsRed(message) + "\n");
-        }
-        return {
-            success: false,
-            exitCode: 78,
-            stdout: "",
-            stderr: message,
-            metadata: {
-                code: "TOOL_AUTHORITY_BLOCKED",
-                nodeId: input.node.id,
-                op: authorityRecord.op,
-                decision: authorityRecord.decision,
-                authorityMode: authorityRecord.mode,
-            },
-        };
-    }
-    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?.();
-    const diagnostics = {};
-    try {
-        const turnRunId = input.env.OMK_RUN_ID ?? input.runContext?.goal.runId ?? input.node.id;
-        const routingWrite = await writeTurnRoutingArtifact(turnRunId, input.node, input.runContext);
-        if (routingWrite?.error)
-            diagnostics.routingWrite = routingWrite.error;
-        const result = await input.taskRunner.run(input.node, input.env, input.signal, input.runContext);
-        const resultWrite = await appendTurnResultArtifact(turnRunId, input.node, result);
-        if (resultWrite?.error)
-            diagnostics.resultWrite = resultWrite.error;
-        await recordTurnAuditGraph({
-            root: input.env.OMK_PROJECT_ROOT ?? process.cwd(),
-            runId: turnRunId,
-            node: input.node,
-            result,
-            resultArtifact: resultWrite?.artifact,
-        });
-        if (Object.keys(diagnostics).length > 0) {
-            result.metadata = {
-                ...(result.metadata ?? {}),
-                artifactWriteDiagnostics: diagnostics,
-            };
-        }
-        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,
-        runId: input.runId,
-    });
-    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,
-        runId: input.runId,
-    });
-    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;
-}