@kaelio/ktx 0.8.0 → 0.9.0

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

@@ -0,0 +1,304 @@
+import { z } from 'zod';
+import { noopLogger } from '../core/config.js';
+import { isCompletedAgentStep, summarizeCodexExecEvents } from './codex-exec-events.js';
+import { startCodexRuntimeMcpServer, } from './codex-mcp-runtime-server.js';
+import { resolveCodexModel } from './codex-models.js';
+import { buildCodexRuntimeConfig } from './codex-runtime-config.js';
+import { CodexSdkCliRunner } from './codex-sdk-runner.js';
+function modelForRole(modelSlots, role) {
+    return resolveCodexModel(modelSlots[role] ?? modelSlots.default);
+}
+function promptWithSystem(system, prompt) {
+    return [system, prompt].filter(Boolean).join('\n\n');
+}
+function eventRecord(value) {
+    return value && typeof value === 'object' ? value : undefined;
+}
+function isTurnCompleted(event) {
+    return eventRecord(event)?.type === 'turn.completed';
+}
+/**
+ * Drains the Codex stream once, emitting a step as each agent action completes
+ * so callers see live progress and the step budget is enforced mid-run. Every
+ * completed agent-action item counts (see {@link isCompletedAgentStep}), so
+ * built-in `command_execution` steps decrement the budget the same as
+ * `mcp_tool_call`s. A turn that produced no actions still counts as one step,
+ * matching the metrics summary and the AI SDK backend.
+ */
+async function collectEvents(events, options = {}) {
+    const collected = [];
+    let completedSteps = 0;
+    let sawActionStep = false;
+    let budgetExceeded = false;
+    let streamError;
+    // The SDK yields every stdout event, then throws on a non-zero codex exec
+    // exit. Catch that throw so the events already collected (which carry the
+    // real `turn.failed`/`error` reason) survive for the summary; the masked
+    // exit message is kept only as a fallback when no error event was emitted.
+    try {
+        for await (const event of events) {
+            collected.push(event);
+            const isActionStep = isCompletedAgentStep(event);
+            if (isActionStep) {
+                sawActionStep = true;
+            }
+            else if (sawActionStep || !isTurnCompleted(event)) {
+                // Only fall back to counting a bare turn as a step when the turn produced
+                // no agent actions; a completed turn is terminal, so it never aborts.
+                continue;
+            }
+            completedSteps += 1;
+            await options.onStep?.(completedSteps);
+            if (isActionStep && options.stepBudget !== undefined && completedSteps >= options.stepBudget) {
+                budgetExceeded = true;
+                options.abortController?.abort();
+                break;
+            }
+        }
+    }
+    catch (error) {
+        streamError = error instanceof Error ? error : new Error(String(error));
+    }
+    return { events: collected, budgetExceeded, ...(streamError ? { streamError } : {}) };
+}
+function metrics(summary, startedAt) {
+    return { totalMs: Date.now() - startedAt, usage: summary.usage };
+}
+function summaryError(summary, streamError) {
+    // A `turn.failed`/`error` event carries the real reason; prefer it over the
+    // SDK's generic non-zero-exit throw. Fall back to the stream error only when
+    // no event explained the failure (e.g. spawn failure or auth before a turn).
+    if (summary.error) {
+        return summary.error;
+    }
+    if (summary.toolFailures.length > 0) {
+        return new Error(`Codex runtime tool call failed: ${summary.toolFailures.join('; ')}`);
+    }
+    return streamError;
+}
+function assertSuccessfulText(summary, streamError) {
+    const error = summaryError(summary, streamError);
+    if (error) {
+        throw error;
+    }
+    if (!summary.finalText.trim()) {
+        throw new Error('Codex completed without an agent message');
+    }
+    return summary.finalText;
+}
+function parseStructuredOutput(schema, text) {
+    try {
+        return schema.parse(JSON.parse(text));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Codex structured output failed validation: ${message}`);
+    }
+}
+async function mcpForTools(input) {
+    if (!input.toolSet || Object.keys(input.toolSet).length === 0) {
+        return undefined;
+    }
+    return (input.startMcpServer ?? startCodexRuntimeMcpServer)({
+        projectDir: input.projectDir,
+        toolSet: input.toolSet,
+    });
+}
+function runtimeToolNames(toolSet) {
+    return Object.values(toolSet ?? {}).map((descriptor) => descriptor.name);
+}
+export class CodexKtxLlmRuntime {
+    deps;
+    runner;
+    logger;
+    constructor(deps) {
+        this.deps = deps;
+        this.runner = deps.runner ?? new CodexSdkCliRunner();
+        this.logger = deps.logger ?? noopLogger;
+    }
+    async generateText(input) {
+        const startedAt = Date.now();
+        const model = modelForRole(this.deps.modelSlots, input.role);
+        const mcp = await mcpForTools({
+            projectDir: this.deps.projectDir,
+            toolSet: input.tools,
+            startMcpServer: this.deps.startMcpServer,
+        });
+        try {
+            const config = buildCodexRuntimeConfig({
+                model,
+                ...(mcp
+                    ? {
+                        mcp: {
+                            url: mcp.url,
+                            bearerTokenEnvVar: mcp.bearerTokenEnvVar,
+                            bearerToken: mcp.bearerToken,
+                            toolNames: runtimeToolNames(input.tools),
+                        },
+                    }
+                    : {}),
+            });
+            const collected = await collectEvents(await this.runner.runStreamed({
+                projectDir: this.deps.projectDir,
+                model,
+                prompt: promptWithSystem(input.system, input.prompt),
+                configOverrides: config.configOverrides,
+                env: config.env,
+            }));
+            const summary = summarizeCodexExecEvents(collected.events, { startedAt });
+            input.onMetrics?.(metrics(summary, startedAt));
+            return assertSuccessfulText(summary, collected.streamError);
+        }
+        finally {
+            await mcp?.close();
+        }
+    }
+    async generateObject(input) {
+        const startedAt = Date.now();
+        const model = modelForRole(this.deps.modelSlots, input.role);
+        const mcp = await mcpForTools({
+            projectDir: this.deps.projectDir,
+            toolSet: input.tools,
+            startMcpServer: this.deps.startMcpServer,
+        });
+        try {
+            const config = buildCodexRuntimeConfig({
+                model,
+                ...(mcp
+                    ? {
+                        mcp: {
+                            url: mcp.url,
+                            bearerTokenEnvVar: mcp.bearerTokenEnvVar,
+                            bearerToken: mcp.bearerToken,
+                            toolNames: runtimeToolNames(input.tools),
+                        },
+                    }
+                    : {}),
+            });
+            const collected = await collectEvents(await this.runner.runStreamed({
+                projectDir: this.deps.projectDir,
+                model,
+                prompt: promptWithSystem(input.system, input.prompt),
+                configOverrides: config.configOverrides,
+                env: config.env,
+                outputSchema: z.toJSONSchema(input.schema, { target: 'draft-7' }),
+            }));
+            const summary = summarizeCodexExecEvents(collected.events, { startedAt });
+            input.onMetrics?.(metrics(summary, startedAt));
+            return parseStructuredOutput(input.schema, assertSuccessfulText(summary, collected.streamError));
+        }
+        finally {
+            await mcp?.close();
+        }
+    }
+    async runAgentLoop(params) {
+        const startedAt = Date.now();
+        const model = modelForRole(this.deps.modelSlots, params.modelRole);
+        let mcp;
+        try {
+            mcp = await mcpForTools({
+                projectDir: this.deps.projectDir,
+                toolSet: params.toolSet,
+                startMcpServer: this.deps.startMcpServer,
+            });
+            const config = buildCodexRuntimeConfig({
+                model,
+                ...(mcp
+                    ? {
+                        mcp: {
+                            url: mcp.url,
+                            bearerTokenEnvVar: mcp.bearerTokenEnvVar,
+                            bearerToken: mcp.bearerToken,
+                            toolNames: runtimeToolNames(params.toolSet),
+                        },
+                    }
+                    : {}),
+            });
+            const abortController = new AbortController();
+            const onStep = async (stepIndex) => {
+                try {
+                    await params.onStepFinish?.({ stepIndex, stepBudget: params.stepBudget });
+                }
+                catch (error) {
+                    this.logger.warn(`[codex-runner] onStepFinish callback threw; ignoring: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            };
+            const collected = await collectEvents(await this.runner.runStreamed({
+                projectDir: this.deps.projectDir,
+                model,
+                prompt: promptWithSystem(params.systemPrompt, params.userPrompt),
+                configOverrides: config.configOverrides,
+                env: config.env,
+                signal: abortController.signal,
+            }), { stepBudget: params.stepBudget, abortController, onStep });
+            const summary = summarizeCodexExecEvents(collected.events, { startedAt });
+            const error = summaryError(summary, collected.streamError);
+            const stopReason = collected.budgetExceeded ? 'budget' : error ? 'error' : summary.stopReason;
+            return {
+                stopReason,
+                ...(stopReason === 'error' && error ? { error } : {}),
+                metrics: {
+                    totalMs: Date.now() - startedAt,
+                    usage: summary.usage,
+                    stepCount: summary.stepCount,
+                    stepBoundariesMs: summary.stepBoundariesMs,
+                },
+            };
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            return {
+                stopReason: 'error',
+                error: err,
+                metrics: { totalMs: Date.now() - startedAt, usage: {}, stepCount: 0, stepBoundariesMs: [] },
+            };
+        }
+        finally {
+            await mcp?.close();
+        }
+    }
+}
+// A rejected model is not an auth failure: Codex authenticated, connected, and
+// the API refused the model id. These markers come from the API error envelope
+// (e.g. "model is not supported", "invalid_request_error").
+const MODEL_UNAVAILABLE_MARKERS = /\bnot supported\b|\bnot available\b|\bdoes not exist\b|invalid_request_error|\bunknown model\b|\bunsupported model\b/i;
+function describeCodexProbeFailure(model, message) {
+    if (MODEL_UNAVAILABLE_MARKERS.test(message)) {
+        const fix = `Run \`codex\` to see the models your account supports, then set llm.models.default in ktx.yaml (or rerun \`ktx setup\`).`;
+        return {
+            message: `Codex is authenticated, but the configured model "${model}" is not available for this Codex account. ${fix} Details: ${message}`,
+            fix,
+        };
+    }
+    const fix = `Authenticate Codex locally with the Codex CLI, verify the Codex CLI is installed, then rerun setup or \`ktx status\`.`;
+    return {
+        message: `Codex authentication is not usable. ${fix} Details: ${message}`,
+        fix,
+    };
+}
+export async function runCodexAuthProbe(input) {
+    let model;
+    try {
+        model = resolveCodexModel(input.model);
+    }
+    catch (error) {
+        return {
+            ok: false,
+            message: error instanceof Error ? error.message : String(error),
+            fix: 'Set llm.models.default in ktx.yaml to a supported codex model (codex, default, or a gpt-* / codex-* id), or rerun `ktx setup`.',
+        };
+    }
+    const runtime = new CodexKtxLlmRuntime({
+        projectDir: input.projectDir,
+        modelSlots: { default: model },
+        ...(input.runner ? { runner: input.runner } : {}),
+    });
+    try {
+        await runtime.generateText({ role: 'default', prompt: 'Reply with exactly: ok' });
+        return { ok: true };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { ok: false, ...describeCodexProbeFailure(model, message) };
+    }
+}

package/dist/context/llm/codex-sdk-runner.d.ts

@@ -0,0 +1,21 @@
+export interface CodexSdkRunnerInput {
+    projectDir: string;
+    model: string;
+    prompt: string;
+    configOverrides?: Record<string, unknown>;
+    env?: Record<string, string>;
+    outputSchema?: Record<string, unknown>;
+    signal?: AbortSignal;
+}
+export interface CodexSdkRunner {
+    runStreamed(input: CodexSdkRunnerInput): Promise<AsyncIterable<unknown>>;
+}
+export interface CodexSdkCliRunnerOptions {
+    envBase?: NodeJS.ProcessEnv;
+    codexPathOverride?: string;
+}
+export declare class CodexSdkCliRunner implements CodexSdkRunner {
+    private readonly options;
+    constructor(options?: CodexSdkCliRunnerOptions);
+    runStreamed(input: CodexSdkRunnerInput): Promise<AsyncIterable<unknown>>;
+}

package/dist/context/llm/codex-sdk-runner.js

@@ -0,0 +1,63 @@
+import { Codex } from '@openai/codex-sdk';
+const CODEX_ENV_ALLOWLIST = new Set([
+    'HOME',
+    'USERPROFILE',
+    'APPDATA',
+    'LOCALAPPDATA',
+    'XDG_CONFIG_HOME',
+    'CODEX_HOME',
+    'CODEX_API_KEY',
+    'OPENAI_API_KEY',
+    'PATH',
+    'Path',
+    'SYSTEMROOT',
+    'COMSPEC',
+    'TMPDIR',
+    'TMP',
+    'TEMP',
+    'SSL_CERT_FILE',
+    'SSL_CERT_DIR',
+    'NODE_EXTRA_CA_CERTS',
+    'HTTPS_PROXY',
+    'HTTP_PROXY',
+    'ALL_PROXY',
+    'NO_PROXY',
+]);
+function buildCodexSdkEnv(baseEnv, overrides) {
+    const env = {};
+    for (const key of CODEX_ENV_ALLOWLIST) {
+        const value = baseEnv[key];
+        if (typeof value === 'string') {
+            env[key] = value;
+        }
+    }
+    return { ...env, ...(overrides ?? {}) };
+}
+export class CodexSdkCliRunner {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async runStreamed(input) {
+        const CodexClass = Codex;
+        const codex = new CodexClass({
+            ...(input.configOverrides ? { config: input.configOverrides } : {}),
+            env: buildCodexSdkEnv(this.options.envBase ?? process.env, input.env),
+            ...(this.options.codexPathOverride ? { codexPathOverride: this.options.codexPathOverride } : {}),
+        });
+        const thread = codex.startThread({
+            workingDirectory: input.projectDir,
+            skipGitRepoCheck: true,
+            model: input.model,
+            sandboxMode: 'read-only',
+            webSearchMode: 'disabled',
+            approvalPolicy: 'never',
+        });
+        const turnOptions = {
+            ...(input.outputSchema ? { outputSchema: input.outputSchema } : {}),
+            ...(input.signal ? { signal: input.signal } : {}),
+        };
+        const streamed = await thread.runStreamed(input.prompt, Object.keys(turnOptions).length > 0 ? turnOptions : undefined);
+        return streamed.events;
+    }
+}

package/dist/context/llm/local-config.d.ts

@@ -3,6 +3,7 @@ import { createKtxLlmProvider } from '../../llm/model-provider.js';
 import type { KtxEmbeddingConfig, KtxEmbeddingProvider, KtxLlmConfig, KtxLlmProvider } from '../../llm/types.js';
 import type { KtxProjectEmbeddingConfig, KtxProjectLlmConfig } from '../project/config.js';
 import { ClaudeCodeKtxLlmRuntime } from './claude-code-runtime.js';
+import { CodexKtxLlmRuntime } from './codex-runtime.js';
 import type { KtxLlmRuntimePort } from './runtime-port.js';
 interface LocalConfigDeps {
     env?: NodeJS.ProcessEnv;
@@ -10,6 +11,7 @@ interface LocalConfigDeps {
     createKtxLlmProvider?: typeof createKtxLlmProvider;
     createKtxEmbeddingProvider?: typeof createKtxEmbeddingProvider;
     createClaudeCodeRuntime?: (deps: ConstructorParameters<typeof ClaudeCodeKtxLlmRuntime>[0]) => KtxLlmRuntimePort;
+    createCodexRuntime?: (deps: ConstructorParameters<typeof CodexKtxLlmRuntime>[0]) => KtxLlmRuntimePort;
     createAiSdkRuntime?: (deps: {
         llmProvider: KtxLlmProvider;
     }) => KtxLlmRuntimePort;

package/dist/context/llm/local-config.js

@@ -3,6 +3,7 @@ import { createKtxLlmProvider } from '../../llm/model-provider.js';
 import { resolveKtxConfigReference } from '../core/config-reference.js';
 import { AiSdkKtxLlmRuntime } from './ai-sdk-runtime.js';
 import { ClaudeCodeKtxLlmRuntime } from './claude-code-runtime.js';
+import { CodexKtxLlmRuntime } from './codex-runtime.js';
 function resolveOptional(value, env) {
     return resolveKtxConfigReference(value, env) || undefined;
 }
@@ -70,7 +71,7 @@ export function resolveLocalKtxLlmConfig(config, env) {
 /** @internal */
 export function createLocalKtxLlmProviderFromConfig(config, deps = {}) {
     const resolved = resolveLocalKtxLlmConfig(config, deps.env ?? process.env);
-    if (!resolved || resolved.backend === 'claude-code') {
+    if (!resolved || resolved.backend === 'claude-code' || resolved.backend === 'codex') {
         return null;
     }
     return (deps.createKtxLlmProvider ?? createKtxLlmProvider)(resolved);
@@ -91,6 +92,16 @@ export function createLocalKtxLlmRuntimeFromConfig(config, deps = {}) {
             env: deps.env,
         });
     }
+    if (resolved.backend === 'codex') {
+        const projectDir = deps.projectDir;
+        if (!projectDir) {
+            throw new Error('projectDir is required when creating the codex LLM runtime');
+        }
+        return (deps.createCodexRuntime ?? ((runtimeDeps) => new CodexKtxLlmRuntime(runtimeDeps)))({
+            projectDir,
+            modelSlots: resolved.modelSlots,
+        });
+    }
     const llmProvider = (deps.createKtxLlmProvider ?? createKtxLlmProvider)(resolved);
     return (deps.createAiSdkRuntime ?? ((runtimeDeps) => new AiSdkKtxLlmRuntime(runtimeDeps)))({ llmProvider });
 }

package/dist/context/project/config.d.ts

@@ -6,6 +6,7 @@ declare const llmSchema: z.ZodObject<{
             vertex: "vertex";
             gateway: "gateway";
             "claude-code": "claude-code";
+            codex: "codex";
             none: "none";
         }>>;
         vertex: z.ZodOptional<z.ZodObject<{
@@ -327,6 +328,7 @@ declare const ktxProjectConfigSchema: z.ZodObject<{
                 vertex: "vertex";
                 gateway: "gateway";
                 "claude-code": "claude-code";
+                codex: "codex";
                 none: "none";
             }>>;
             vertex: z.ZodOptional<z.ZodObject<{

package/dist/context/project/config.js

@@ -2,7 +2,7 @@ import { KTX_MODEL_ROLES } from '../../llm/types.js';
 import YAML from 'yaml';
 import * as z from 'zod';
 import { connectionConfigSchema } from './driver-schemas.js';
-const KTX_LLM_BACKENDS = ['none', 'anthropic', 'vertex', 'gateway', 'claude-code'];
+const KTX_LLM_BACKENDS = ['none', 'anthropic', 'vertex', 'gateway', 'claude-code', 'codex'];
 const KTX_EMBEDDING_BACKENDS = ['none', 'openai', 'sentence-transformers'];
 const KTX_PROMPT_CACHE_TTLS = ['5m', '1h'];
 const KTX_ENRICHMENT_MODES = ['none', 'deterministic', 'llm'];
@@ -32,7 +32,7 @@ const llmProviderSchema = z
     backend: z
         .enum(KTX_LLM_BACKENDS)
         .default('none')
-        .describe('LLM provider backend. "none" disables LLM features; "anthropic" / "vertex" / "gateway" require the matching nested credentials block; "claude-code" uses the local Claude Code session.'),
+        .describe('LLM provider backend. "none" disables LLM features; "anthropic" / "vertex" / "gateway" require the matching nested credentials block; "claude-code" uses the local Claude Code session; "codex" uses the local Codex session.'),
     vertex: vertexProviderSchema.optional().describe('Vertex AI credentials, used when backend is "vertex".'),
     anthropic: apiCredentialsSchema.optional().describe('Anthropic API credentials, used when backend is "anthropic".'),
     gateway: apiCredentialsSchema.optional().describe('AI Gateway credentials, used when backend is "gateway".'),

package/dist/context/sql-analysis/http-sql-analysis-port.js

@@ -59,6 +59,13 @@ function optionalString(raw, field) {
     }
     throw new Error(`sql analysis response has invalid optional string field ${field}`);
 }
+function optionalNullableStringField(raw, field) {
+    const value = raw[field];
+    if (value === null || value === undefined || typeof value === 'string') {
+        return value ?? null;
+    }
+    throw new Error(`sql analysis response has invalid optional nullable string field ${field}`);
+}
 function requiredStringArray(raw, field) {
     const value = raw[field];
     if (!Array.isArray(value) || value.some((item) => typeof item !== 'string')) {
@@ -136,10 +143,32 @@ function mapColumnsByClause(raw) {
     }
     return result;
 }
+function requiredTableRef(raw, field) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        throw new Error(`sql analysis response contains invalid table ref in ${field}`);
+    }
+    const record = raw;
+    const name = record.name;
+    if (typeof name !== 'string' || name.length === 0) {
+        throw new Error(`sql analysis response table ref in ${field} is missing name`);
+    }
+    return {
+        catalog: optionalNullableStringField(record, 'catalog'),
+        db: optionalNullableStringField(record, 'db'),
+        name,
+    };
+}
+function requiredTableRefArray(raw, field) {
+    const value = raw[field];
+    if (!Array.isArray(value)) {
+        throw new Error(`sql analysis response is missing table-ref[] field ${field}`);
+    }
+    return value.map((item, index) => requiredTableRef(item, `${field}.${index}`));
+}
 function mapBatchResult(raw) {
     const error = optionalString(raw, 'error');
     return {
-        tablesTouched: requiredStringArray(raw, 'tables_touched'),
+        tablesTouched: requiredTableRefArray(raw, 'tables_touched'),
         columnsByClause: mapColumnsByClause(raw),
         ...(error !== undefined ? { error } : {}),
     };
@@ -170,10 +199,11 @@ export function createHttpSqlAnalysisPort(options) {
             });
             return mapResult(raw);
         },
-        async analyzeBatch(items, dialect) {
+        async analyzeBatch(items, dialect, options) {
             const raw = await requestJson('/sql/analyze-batch', {
                 dialect,
                 items,
+                ...(options?.catalog ? { catalog: options.catalog } : {}),
             });
             return mapBatchResponse(raw);
         },

package/dist/context/sql-analysis/ports.d.ts

@@ -1,3 +1,4 @@
+import type { KtxTableRef } from '../scan/types.js';
 export type SqlAnalysisDialect = 'bigquery' | 'snowflake' | 'postgres' | 'redshift' | 'mysql' | 'sqlite' | 'tsql' | 'clickhouse' | (string & {});
 export type SqlAnalysisLiteralSlotType = 'string' | 'number' | 'timestamp' | 'date' | 'boolean' | 'null' | 'unknown';
 export interface SqlAnalysisLiteralSlot {
@@ -17,8 +18,17 @@ export interface SqlAnalysisBatchItem {
     id: string;
     sql: string;
 }
+interface SqlAnalysisCatalogTable extends KtxTableRef {
+    columns?: string[];
+}
+interface SqlAnalysisCatalog {
+    tables: SqlAnalysisCatalogTable[];
+}
+export interface SqlAnalysisBatchOptions {
+    catalog?: SqlAnalysisCatalog;
+}
 export interface SqlAnalysisBatchResult {
-    tablesTouched: string[];
+    tablesTouched: KtxTableRef[];
     columnsByClause: Partial<Record<SqlAnalysisClause, string[]>>;
     error?: string | null;
 }
@@ -28,7 +38,7 @@ export interface SqlReadOnlyValidationResult {
 }
 export interface SqlAnalysisPort {
     analyzeForFingerprint(sql: string, dialect: SqlAnalysisDialect): Promise<SqlAnalysisFingerprintResult>;
-    analyzeBatch(items: SqlAnalysisBatchItem[], dialect: SqlAnalysisDialect): Promise<Map<string, SqlAnalysisBatchResult>>;
+    analyzeBatch(items: SqlAnalysisBatchItem[], dialect: SqlAnalysisDialect, options?: SqlAnalysisBatchOptions): Promise<Map<string, SqlAnalysisBatchResult>>;
     validateReadOnly(sql: string, dialect: SqlAnalysisDialect): Promise<SqlReadOnlyValidationResult>;
 }
 export {};

package/dist/context/tools/context-candidate-mark.tool.d.ts

@@ -8,8 +8,8 @@ declare const contextCandidateMarkInputSchema: z.ZodObject<{
         conflict: "conflict";
         merged: "merged";
         pending: "pending";
-        promoted: "promoted";
         rejected: "rejected";
+        promoted: "promoted";
     }>;
     rejectionReason: z.ZodDefault<z.ZodNullable<z.ZodString>>;
 }, z.core.$strip>;
@@ -31,8 +31,8 @@ export declare class ContextCandidateMarkTool extends BaseTool<typeof contextCan
             conflict: "conflict";
             merged: "merged";
             pending: "pending";
-            promoted: "promoted";
             rejected: "rejected";
+            promoted: "promoted";
         }>;
         rejectionReason: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     }, z.core.$strip>;

package/dist/context-build-view.js

@@ -1,5 +1,5 @@
-import { publicDatabaseIngestMessage, publicQueryHistoryMessage } from './public-ingest-copy.js';
-import { buildPublicIngestPlan, executePublicIngestTarget } from './public-ingest.js';
+import { buildPublicIngestPlan, executePublicIngestTarget, publicProgressMessage } from './public-ingest.js';
+import { createAggregateProgressPort } from './progress-port-adapter.js';
 import { formatDuration } from './demo-metrics.js';
 import { profileMark } from './startup-profile.js';
 profileMark('module:context-build-view');
@@ -618,38 +618,10 @@ export function initViewState(targets) {
         totalElapsedMs: 0,
     };
 }
-function publicProgressMessage(message, target) {
-    let current = message;
-    if (target.operation === 'database-ingest') {
-        current = publicDatabaseIngestMessage(current);
-    }
-    if (target.steps.includes('query-history')) {
-        current = publicQueryHistoryMessage(current, target.connectionId);
-    }
-    return current;
-}
 function formatProgressDetail(update, target) {
     const percent = Math.max(0, Math.min(100, Math.round(update.percent)));
     return `[${percent}%] ${publicProgressMessage(update.message, target)}`;
 }
-function createContextBuildProgressPort(onProgress, state = { progress: 0 }, start = 0, weight = 1) {
-    return {
-        async update(value, message, options) {
-            const absoluteValue = start + Math.max(0, Math.min(1, value)) * weight;
-            state.progress = Math.max(state.progress, Math.min(1, absoluteValue));
-            if (!message)
-                return;
-            onProgress({
-                percent: Math.max(0, Math.min(100, Math.round(state.progress * 100))),
-                message,
-                ...(options?.transient !== undefined ? { transient: options.transient } : {}),
-            });
-        },
-        startPhase(phaseWeight) {
-            return createContextBuildProgressPort(onProgress, state, state.progress, weight * phaseWeight);
-        },
-    };
-}
 export async function runContextBuild(project, args, io, deps = {}) {
     const plan = buildPublicIngestPlan(project, {
         projectDir: args.projectDir,
@@ -802,7 +774,7 @@ export async function runContextBuild(project, args, io, deps = {}) {
                 hasPendingProgressPublish = !publishSourceProgress(false);
             };
             const progressDeps = {
-                scanProgress: createContextBuildProgressPort(updateSchemaPhase),
+                scanProgress: createAggregateProgressPort(updateSchemaPhase),
                 ingestProgress: updateIngestPhase,
                 runtimeIo: io,
                 onPhaseStart,
@@ -811,7 +783,7 @@ export async function runContextBuild(project, args, io, deps = {}) {
             let result = null;
             let thrownError = null;
             try {
-                result = await execTarget(targetState.target, runArgs, capture.io, progressDeps);
+                result = await execTarget(targetState.target, runArgs, capture.io, progressDeps, project);
             }
             catch (error) {
                 thrownError = error;

package/dist/io/buffered-command-io.d.ts

@@ -0,0 +1,11 @@
+import type { KtxCliIo } from '../cli-runtime.js';
+export interface BufferedCommandIo extends KtxCliIo {
+    stdoutText(): string;
+    stderrText(): string;
+}
+/**
+ * Captures stdout/stderr from a command (e.g. `runKtxConnection`) into buffers
+ * instead of the terminal. Callers decide whether to flush the captured text to
+ * the user or discard it.
+ */
+export declare function createBufferedCommandIo(): BufferedCommandIo;