@kaelio/ktx 0.8.0 → 0.9.0

package/dist/context/ingest/context-evidence/sqlite-context-evidence-store.d.ts

@@ -47,7 +47,7 @@ export declare class SqliteContextEvidenceStore implements ContextEvidenceIndexS
         assertion: string;
         rationale: string;
         actionHint: string;
-        status: "conflict" | "merged" | "pending" | "promoted" | "rejected";
+        status: "conflict" | "merged" | "pending" | "rejected" | "promoted";
         promotionScore: number;
         suggestedPageKey: string | null;
         evidenceRefs: JsonValue;

package/dist/context/ingest/isolated-diff/patch-integrator.js

@@ -85,18 +85,88 @@ export async function integrateWorkUnitPatch(input) {
             });
         }
         catch (semanticError) {
-            if (preApplyHead) {
-                await input.integrationGit.resetHardTo(preApplyHead);
-            }
+            const reason = errorMessage(semanticError);
             await input.trace.event('error', 'integration', 'patch_semantic_conflict_after_textual_resolution', {
                 unitKey: input.unitKey,
                 patchPath: input.patchPath,
                 touchedPaths: textualResolution.changedPaths,
-                reason: errorMessage(semanticError),
+                reason,
             });
+            // A textual conflict and a semantic-gate failure can co-occur: the resolver
+            // reconciles the text but can leave wiki sl_refs pointing at measures the
+            // merged source no longer defines. Recover via the same gate repair the
+            // clean-apply branch uses, instead of hard-failing the whole job.
+            if (input.repairGateFailure) {
+                const gateRepair = await input.repairGateFailure({
+                    unitKey: input.unitKey,
+                    patchPath: input.patchPath,
+                    touchedPaths: textualResolution.changedPaths,
+                    reason,
+                });
+                if (gateRepair.status !== 'failed') {
+                    // The resolver wrote its merge to the worktree (unstaged); the repair
+                    // edited a subset on top. Commit the union so neither is dropped.
+                    const resolvedAndRepairedPaths = [
+                        ...new Set([...textualResolution.changedPaths, ...gateRepair.changedPaths]),
+                    ].sort();
+                    try {
+                        await traceTimed(input.trace, 'integration', 'semantic_gate_after_gate_repair', { unitKey: input.unitKey, touchedPaths: gateRepair.changedPaths }, async () => {
+                            await input.validateAppliedTree(gateRepair.changedPaths);
+                        });
+                        const commit = await input.integrationGit.commitFiles(resolvedAndRepairedPaths, `ingest: resolve WorkUnit ${input.unitKey} conflict`, input.author.name, input.author.email);
+                        if (commit.created) {
+                            await input.trace.event('debug', 'integration', 'patch_accepted_after_textual_resolution', {
+                                unitKey: input.unitKey,
+                                commitSha: commit.commitHash,
+                                touchedPaths: resolvedAndRepairedPaths,
+                                attempts: textualResolution.attempts,
+                                gateRepairAttempts: gateRepair.attempts,
+                            });
+                            return {
+                                status: 'accepted',
+                                commitSha: commit.commitHash,
+                                touchedPaths: resolvedAndRepairedPaths,
+                                textualResolution,
+                                gateRepair,
+                            };
+                        }
+                    }
+                    catch (repairValidationError) {
+                        if (preApplyHead) {
+                            await input.integrationGit.resetHardTo(preApplyHead);
+                        }
+                        await input.trace.event('error', 'integration', 'patch_semantic_conflict_after_textual_resolution', {
+                            unitKey: input.unitKey,
+                            patchPath: input.patchPath,
+                            touchedPaths: gateRepair.changedPaths,
+                            reason: errorMessage(repairValidationError),
+                        });
+                        return {
+                            status: 'semantic_conflict',
+                            reason: errorMessage(repairValidationError),
+                            touchedPaths: gateRepair.changedPaths,
+                            textualResolution,
+                            gateRepair,
+                        };
+                    }
+                }
+                if (preApplyHead) {
+                    await input.integrationGit.resetHardTo(preApplyHead);
+                }
+                return {
+                    status: 'semantic_conflict',
+                    reason: gateRepair.status === 'failed' ? gateRepair.reason : reason,
+                    touchedPaths: textualResolution.changedPaths,
+                    textualResolution,
+                    gateRepair,
+                };
+            }
+            if (preApplyHead) {
+                await input.integrationGit.resetHardTo(preApplyHead);
+            }
             return {
                 status: 'semantic_conflict',
-                reason: errorMessage(semanticError),
+                reason,
                 touchedPaths: textualResolution.changedPaths,
                 textualResolution,
             };

package/dist/context/ingest/local-adapters.js

@@ -7,6 +7,7 @@ import { DbtSourceAdapter } from './adapters/dbt/dbt.adapter.js';
 import { FakeSourceAdapter } from './adapters/fake/fake.adapter.js';
 import { HistoricSqlSourceAdapter } from './adapters/historic-sql/historic-sql.adapter.js';
 import { PostgresPgssReader } from './adapters/historic-sql/postgres-pgss-reader.js';
+import { resolveQueryHistoryScopeFloor } from './adapters/historic-sql/scope-floor.js';
 import { HISTORIC_SQL_SOURCE_KEY, historicSqlUnifiedPullConfigSchema, } from './adapters/historic-sql/types.js';
 import { createDaemonLiveDatabaseIntrospection, } from './adapters/live-database/daemon-introspection.js';
 import { LiveDatabaseSourceAdapter } from './adapters/live-database/live-database.adapter.js';
@@ -113,14 +114,30 @@ function queryHistoryRecord(connection) {
     const queryHistory = isRecord(context?.queryHistory) ? context.queryHistory : null;
     return queryHistory;
 }
-function queryHistoryPullConfig(connection) {
+async function queryHistoryPullConfig(project, connectionId, connection) {
     const queryHistory = queryHistoryRecord(connection);
     if (queryHistory?.enabled !== true || !isRecord(connection))
         return null;
-    const dialect = historicSqlDialectByDriver.get(String(connection.driver ?? '').toLowerCase());
+    const driver = String(connection.driver ?? '').toLowerCase();
+    const dialect = historicSqlDialectByDriver.get(driver);
     if (!dialect)
         return null;
-    return { ...queryHistory, dialect };
+    const scopeFloor = await resolveQueryHistoryScopeFloor({
+        projectDir: project.projectDir,
+        connectionId,
+        driver,
+        connection,
+        storedQueryHistory: queryHistory,
+    });
+    const { enabled: _enabled, dialect: _dialect, enabledTables: _enabledTables, enabledSchemas: _enabledSchemas, scopeFloorWarnings: _scopeFloorWarnings, ...stored } = queryHistory;
+    return {
+        ...stored,
+        dialect,
+        ...(scopeFloor.enabledTables.length > 0 ? { enabledTables: scopeFloor.enabledTables } : {}),
+        ...(scopeFloor.enabledSchemas.length > 0 ? { enabledSchemas: scopeFloor.enabledSchemas } : {}),
+        ...(scopeFloor.modeledTableCatalog.length > 0 ? { modeledTableCatalog: scopeFloor.modeledTableCatalog } : {}),
+        ...(scopeFloor.warnings.length > 0 ? { scopeFloorWarnings: scopeFloor.warnings } : {}),
+    };
 }
 function stringField(value) {
     return typeof value === 'string' && value.trim().length > 0 ? value.trim() : null;
@@ -168,7 +185,7 @@ export async function localPullConfigForAdapter(project, adapter, connectionId,
         if (options.historicSqlPullConfigOverride) {
             return historicSqlUnifiedPullConfigSchema.parse(options.historicSqlPullConfigOverride);
         }
-        const queryHistory = queryHistoryPullConfig(connection);
+        const queryHistory = await queryHistoryPullConfig(project, connectionId, connection);
         if (!queryHistory) {
             throw new Error(`Connection "${connectionId}" does not have context.queryHistory.enabled: true`);
         }

package/dist/context/ingest/local-bundle-runtime.js

@@ -488,9 +488,10 @@ function nextLocalJobId() {
 }
 function localIngestLlmProviderGuardMessage(projectDir) {
     return [
-        'ktx ingest requires llm.provider.backend: anthropic, vertex, gateway, or claude-code, or an injected agentRunner.',
-        'Configure a local Claude Code session or API-backed LLM, then rerun ingest:',
+        'ktx ingest requires llm.provider.backend: anthropic, vertex, gateway, claude-code, or codex, or an injected agentRunner.',
+        'Configure a local Claude Code/Codex session or API-backed LLM, then rerun ingest:',
         `  ktx setup --project-dir ${projectDir} --llm-backend claude-code --no-input`,
+        `  ktx setup --project-dir ${projectDir} --llm-backend codex --llm-model gpt-5.5 --no-input`,
         `  ktx setup --project-dir ${projectDir} --llm-backend anthropic --anthropic-api-key-env ANTHROPIC_API_KEY --llm-model claude-sonnet-4-6 --no-input`,
     ].join('\n');
 }

package/dist/context/llm/codex-exec-events.d.ts

@@ -0,0 +1,20 @@
+import type { LlmTokenUsage, RunLoopStopReason } from './runtime-port.js';
+export interface CodexExecEventSummary {
+    finalText: string;
+    stopReason: RunLoopStopReason;
+    usage: LlmTokenUsage;
+    stepCount: number;
+    stepBoundariesMs: number[];
+    toolCallCount: number;
+    toolFailures: string[];
+    error?: Error;
+}
+interface CodexEventParseOptions {
+    startedAt?: number;
+    now?: () => number;
+}
+export declare function isCompletedAgentStep(event: unknown): boolean;
+/** @internal */
+export declare function parseCodexExecEventLine(line: string): unknown;
+export declare function summarizeCodexExecEvents(events: Iterable<unknown>, options?: CodexEventParseOptions): CodexExecEventSummary;
+export {};

package/dist/context/llm/codex-exec-events.js

@@ -0,0 +1,155 @@
+function record(value) {
+    return value && typeof value === 'object' ? value : undefined;
+}
+/**
+ * Codex thread items that represent a discrete agent action consuming one loop
+ * step. The step budget caps the total number of these regardless of which
+ * capability the agent reaches for, so built-in `command_execution` (and any
+ * file/web action the public Codex surface still exposes) count alongside our
+ * own `mcp_tool_call` items rather than only the MCP ones.
+ */
+const AGENT_STEP_ITEM_TYPES = new Set(['command_execution', 'mcp_tool_call', 'file_change', 'web_search']);
+export function isCompletedAgentStep(event) {
+    const eventRecord = record(event);
+    if (eventRecord?.type !== 'item.completed') {
+        return false;
+    }
+    const itemType = record(eventRecord.item)?.type;
+    return typeof itemType === 'string' && AGENT_STEP_ITEM_TYPES.has(itemType);
+}
+function text(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value : undefined;
+}
+function numberValue(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function usageFrom(value) {
+    const usage = record(value);
+    if (!usage) {
+        return {};
+    }
+    const inputTokens = numberValue(usage.input_tokens ?? usage.inputTokens);
+    const outputTokens = numberValue(usage.output_tokens ?? usage.outputTokens);
+    const explicitTotalTokens = numberValue(usage.total_tokens ?? usage.totalTokens);
+    const totalTokens = explicitTotalTokens ??
+        (inputTokens !== undefined && outputTokens !== undefined ? inputTokens + outputTokens : undefined);
+    return {
+        ...(inputTokens !== undefined ? { inputTokens } : {}),
+        ...(outputTokens !== undefined ? { outputTokens } : {}),
+        ...(totalTokens !== undefined ? { totalTokens } : {}),
+    };
+}
+function stopReasonFrom(value) {
+    const reason = text(value)?.toLowerCase();
+    if (reason && /(budget|max_turn|max-turn|limit)/.test(reason)) {
+        return 'budget';
+    }
+    return 'natural';
+}
+function errorMessageFrom(value) {
+    if (value instanceof Error) {
+        return value.message;
+    }
+    const asRecord = record(value);
+    const message = text(asRecord?.message);
+    return message ?? text(value) ?? 'Codex turn failed';
+}
+/**
+ * Codex serializes API failures as a JSON envelope inside the event message
+ * (e.g. `{"type":"error","status":400,"error":{"message":"…"}}`). Surface the
+ * human-readable inner message so callers don't leak raw JSON; pass plain
+ * strings through unchanged.
+ */
+function unwrapCodexApiErrorMessage(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed.startsWith('{')) {
+        return raw;
+    }
+    try {
+        const parsed = record(JSON.parse(trimmed));
+        return text(record(parsed?.error)?.message) ?? text(parsed?.message) ?? raw;
+    }
+    catch {
+        return raw;
+    }
+}
+/** @internal */
+export function parseCodexExecEventLine(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch (error) {
+        throw new Error(`Codex JSONL event stream was malformed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export function summarizeCodexExecEvents(events, options = {}) {
+    const startedAt = options.startedAt ?? Date.now();
+    const now = options.now ?? Date.now;
+    let finalText = '';
+    let stopReason = 'natural';
+    let usage = {};
+    let turnCount = 0;
+    let completedStepCount = 0;
+    const stepBoundariesMs = [];
+    let toolCallCount = 0;
+    const toolFailures = [];
+    let error;
+    for (const event of events) {
+        const eventRecord = record(event);
+        const eventType = text(eventRecord?.type);
+        if (!eventRecord || !eventType) {
+            continue;
+        }
+        if (eventType === 'turn.started') {
+            turnCount += 1;
+            continue;
+        }
+        const item = record(eventRecord.item);
+        const itemType = text(item?.type);
+        if (eventType === 'item.started' && itemType === 'mcp_tool_call') {
+            toolCallCount += 1;
+            continue;
+        }
+        if (isCompletedAgentStep(event)) {
+            completedStepCount += 1;
+            stepBoundariesMs.push(now() - startedAt);
+            // Only MCP tool calls fail the loop: a non-zero `command_execution` exit
+            // is normal agent exploration, not a runtime error. `status` is the
+            // authoritative signal (the SDK always sets it); the SDK also serializes
+            // `error: null` on successful calls, so an explicit-null `error` must NOT
+            // be read as a failure — only a populated error object counts.
+            if (itemType === 'mcp_tool_call' && (item?.status === 'failed' || (item?.error !== undefined && item?.error !== null))) {
+                const name = text(item?.name) ?? text(item?.tool) ?? text(item?.tool_name) ?? 'unknown';
+                toolFailures.push(`${name}: ${errorMessageFrom(item?.error)}`);
+            }
+            continue;
+        }
+        if (eventType === 'item.completed' && itemType === 'agent_message') {
+            finalText = text(item?.text) ?? finalText;
+            continue;
+        }
+        if (eventType === 'turn.completed') {
+            usage = usageFrom(eventRecord.usage);
+            if (completedStepCount === 0) {
+                stepBoundariesMs.push(now() - startedAt);
+            }
+            stopReason = stopReasonFrom(eventRecord.reason ?? eventRecord.stop_reason ?? eventRecord.terminal_reason);
+            continue;
+        }
+        if (eventType === 'turn.failed' || eventType === 'error') {
+            stopReason = 'error';
+            error = new Error(unwrapCodexApiErrorMessage(errorMessageFrom(eventRecord.error ?? eventRecord.message)));
+            continue;
+        }
+    }
+    return {
+        finalText,
+        stopReason,
+        usage,
+        stepCount: completedStepCount > 0 ? completedStepCount : turnCount,
+        stepBoundariesMs,
+        toolCallCount,
+        toolFailures,
+        ...(error ? { error } : {}),
+    };
+}

package/dist/context/llm/codex-isolation.d.ts

@@ -0,0 +1,3 @@
+export declare const CODEX_ISOLATION_WARNING = "Codex backend isolation is limited by the public Codex SDK/CLI surface: ktx restricts the runtime MCP server to the current ktx tool set, disables Codex web search, asks for a read-only sandbox, and sets approval_policy=never, but Codex may still load user Codex config and built-in command execution or read-only file capabilities.";
+export declare const CODEX_ISOLATION_WARNING_FIX = "Use llm.provider.backend: claude-code when you need stricter Claude-Code-style runtime tool isolation, or remove host Codex MCP/tool config before running untrusted prompts through the codex backend.";
+export declare function formatCodexIsolationWarning(): string;

package/dist/context/llm/codex-isolation.js

@@ -0,0 +1,5 @@
+export const CODEX_ISOLATION_WARNING = 'Codex backend isolation is limited by the public Codex SDK/CLI surface: ktx restricts the runtime MCP server to the current ktx tool set, disables Codex web search, asks for a read-only sandbox, and sets approval_policy=never, but Codex may still load user Codex config and built-in command execution or read-only file capabilities.';
+export const CODEX_ISOLATION_WARNING_FIX = 'Use llm.provider.backend: claude-code when you need stricter Claude-Code-style runtime tool isolation, or remove host Codex MCP/tool config before running untrusted prompts through the codex backend.';
+export function formatCodexIsolationWarning() {
+    return `${CODEX_ISOLATION_WARNING} ${CODEX_ISOLATION_WARNING_FIX}`;
+}

package/dist/context/llm/codex-mcp-runtime-server.d.ts

@@ -0,0 +1,24 @@
+import type { KtxMcpServerLike } from '../mcp/types.js';
+import { runKtxMcpHttpServer } from '../../mcp-http-server.js';
+import type { KtxRuntimeToolSet } from './runtime-port.js';
+/** @internal */
+export interface CreateCodexRuntimeMcpServerInput {
+    server?: KtxMcpServerLike;
+    toolSet: KtxRuntimeToolSet;
+}
+export interface CodexRuntimeMcpServerHandle {
+    url: string;
+    bearerTokenEnvVar: 'KTX_CODEX_RUNTIME_MCP_TOKEN';
+    bearerToken: string;
+    close(): Promise<void>;
+}
+type RunServer = typeof runKtxMcpHttpServer;
+export interface StartCodexRuntimeMcpServerInput {
+    projectDir: string;
+    toolSet: KtxRuntimeToolSet;
+    runServer?: RunServer;
+}
+/** @internal */
+export declare function createCodexRuntimeMcpServer(input: CreateCodexRuntimeMcpServerInput): KtxMcpServerLike;
+export declare function startCodexRuntimeMcpServer(input: StartCodexRuntimeMcpServerInput): Promise<CodexRuntimeMcpServerHandle>;
+export {};

package/dist/context/llm/codex-mcp-runtime-server.js

@@ -0,0 +1,51 @@
+import { randomBytes } from 'node:crypto';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { runKtxMcpHttpServer } from '../../mcp-http-server.js';
+import { normalizeKtxRuntimeToolOutput } from './runtime-tools.js';
+/** @internal */
+export function createCodexRuntimeMcpServer(input) {
+    const server = input.server ??
+        new McpServer({
+            name: 'ktx-runtime',
+            version: '0.0.0',
+        });
+    for (const descriptor of Object.values(input.toolSet)) {
+        server.registerTool(descriptor.name, {
+            description: descriptor.description,
+            inputSchema: descriptor.inputSchema.shape,
+        }, async (toolInput) => {
+            const normalized = normalizeKtxRuntimeToolOutput(await descriptor.execute(toolInput));
+            return {
+                content: [{ type: 'text', text: normalized.markdown }],
+                ...(normalized.structured !== undefined && normalized.structured !== null && typeof normalized.structured === 'object'
+                    ? { structuredContent: normalized.structured }
+                    : {}),
+            };
+        });
+    }
+    return server;
+}
+function serverPort(server, fallback) {
+    const address = server.address();
+    return typeof address === 'object' && address ? address.port : fallback;
+}
+export async function startCodexRuntimeMcpServer(input) {
+    const bearerToken = randomBytes(32).toString('hex');
+    const runServer = input.runServer ?? runKtxMcpHttpServer;
+    const handle = (await runServer({
+        projectDir: input.projectDir,
+        host: '127.0.0.1',
+        port: 0,
+        token: bearerToken,
+        allowedHosts: ['127.0.0.1', 'localhost'],
+        allowedOrigins: [],
+        createMcpServer: () => createCodexRuntimeMcpServer({ toolSet: input.toolSet }),
+    }));
+    const port = serverPort(handle.server, 0);
+    return {
+        url: `http://127.0.0.1:${port}/mcp`,
+        bearerTokenEnvVar: 'KTX_CODEX_RUNTIME_MCP_TOKEN',
+        bearerToken,
+        close: () => handle.close(),
+    };
+}

package/dist/context/llm/codex-models.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_CODEX_MODEL = "gpt-5.5";
+export declare function resolveCodexModel(model: string): string;

package/dist/context/llm/codex-models.js

@@ -0,0 +1,17 @@
+export const DEFAULT_CODEX_MODEL = 'gpt-5.5';
+const CODEX_MODEL_ALIASES = {
+    codex: DEFAULT_CODEX_MODEL,
+    default: DEFAULT_CODEX_MODEL,
+};
+const EXPLICIT_CODEX_MODEL_ID = /^(?:gpt|codex)-[a-z0-9][a-z0-9._-]*$/i;
+export function resolveCodexModel(model) {
+    const normalized = model.trim();
+    const alias = CODEX_MODEL_ALIASES[normalized];
+    if (alias) {
+        return alias;
+    }
+    if (EXPLICIT_CODEX_MODEL_ID.test(normalized)) {
+        return normalized;
+    }
+    throw new Error(`Unsupported Codex model "${model}". Use codex, default, or a gpt-* / codex-* model id.`);
+}

package/dist/context/llm/codex-runtime-config.d.ts

@@ -0,0 +1,16 @@
+interface CodexRuntimeMcpConfig {
+    url: string;
+    bearerTokenEnvVar: string;
+    bearerToken: string;
+    toolNames: string[];
+}
+export interface BuildCodexRuntimeConfigInput {
+    model: string;
+    mcp?: CodexRuntimeMcpConfig;
+}
+export interface CodexRuntimeConfig {
+    configOverrides: Record<string, unknown>;
+    env: Record<string, string>;
+}
+export declare function buildCodexRuntimeConfig(input: BuildCodexRuntimeConfigInput): CodexRuntimeConfig;
+export {};

package/dist/context/llm/codex-runtime-config.js

@@ -0,0 +1,19 @@
+export function buildCodexRuntimeConfig(input) {
+    const configOverrides = {
+        history: { persistence: 'none' },
+    };
+    const env = {};
+    if (input.mcp) {
+        configOverrides.mcp_servers = {
+            ktx: {
+                url: input.mcp.url,
+                bearer_token_env_var: input.mcp.bearerTokenEnvVar,
+                enabled_tools: input.mcp.toolNames,
+                default_tools_approval_mode: 'approve',
+                required: true,
+            },
+        };
+        env[input.mcp.bearerTokenEnvVar] = input.mcp.bearerToken;
+    }
+    return { configOverrides, env };
+}

package/dist/context/llm/codex-runtime.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import { type KtxLogger } from '../core/config.js';
+import { type CodexRuntimeMcpServerHandle } from './codex-mcp-runtime-server.js';
+import { type CodexSdkRunner } from './codex-sdk-runner.js';
+import type { KtxGenerateObjectInput, KtxGenerateTextInput, KtxLlmRuntimePort, KtxRuntimeToolSet, RunLoopParams, RunLoopResult } from './runtime-port.js';
+export interface CodexKtxLlmRuntimeDeps {
+    projectDir: string;
+    modelSlots: {
+        default: string;
+    } & Partial<Record<string, string>>;
+    runner?: CodexSdkRunner;
+    startMcpServer?: (input: {
+        projectDir: string;
+        toolSet: KtxRuntimeToolSet;
+    }) => Promise<CodexRuntimeMcpServerHandle>;
+    logger?: KtxLogger;
+}
+export declare class CodexKtxLlmRuntime implements KtxLlmRuntimePort {
+    private readonly deps;
+    private readonly runner;
+    private readonly logger;
+    constructor(deps: CodexKtxLlmRuntimeDeps);
+    generateText(input: KtxGenerateTextInput): Promise<string>;
+    generateObject<TOutput, TSchema extends z.ZodType<TOutput>>(input: KtxGenerateObjectInput<TOutput, TSchema>): Promise<TOutput>;
+    runAgentLoop(params: RunLoopParams): Promise<RunLoopResult>;
+}
+export declare function runCodexAuthProbe(input: {
+    projectDir: string;
+    model: string;
+    runner?: CodexSdkRunner;
+}): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    message: string;
+    fix: string;
+}>;