@kaelio/ktx 0.9.0 → 0.11.0

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

@@ -12,11 +12,6 @@ export interface KtxRuntimeToolDescriptor<TInput = unknown, TOutput = unknown> {
 }
 export type KtxRuntimeToolSet = Record<string, KtxRuntimeToolDescriptor>;
 export type RunLoopStopReason = 'budget' | 'natural' | 'error';
-/** @internal */
-export interface RunLoopStepInfo {
-    stepIndex: number;
-    stepBudget: number;
-}
 export interface LlmTokenUsage {
     inputTokens?: number;
     outputTokens?: number;
@@ -40,7 +35,7 @@ export interface RunLoopParams {
     toolSet: KtxRuntimeToolSet;
     stepBudget: number;
     telemetryTags: Record<string, string>;
-    onStepFinish?: (info: RunLoopStepInfo) => void | Promise<void>;
+    abortSignal?: AbortSignal;
 }
 export interface RunLoopResult {
     stopReason: RunLoopStopReason;
@@ -57,6 +52,7 @@ export interface KtxGenerateTextInput {
         totalMs: number;
         usage: LlmTokenUsage;
     }) => void;
+    abortSignal?: AbortSignal;
 }
 export interface KtxGenerateObjectInput<TOutput, TSchema extends z.ZodType<TOutput>> {
     role: KtxModelRole;
@@ -69,6 +65,7 @@ export interface KtxGenerateObjectInput<TOutput, TSchema extends z.ZodType<TOutp
         totalMs: number;
         usage: LlmTokenUsage;
     }) => void;
+    abortSignal?: AbortSignal;
 }
 export interface KtxLlmRuntimePort {
     generateText(input: KtxGenerateTextInput): Promise<string>;

package/dist/context/mcp/context-tools.js

@@ -1,6 +1,7 @@
 import { randomUUID } from 'node:crypto';
 import { z } from 'zod';
-import { emitTelemetryEvent, mcpTelemetrySampleRate, shouldEmitMcpTelemetry } from '../../telemetry/index.js';
+import { emitTelemetryEvent, mcpTelemetrySampleRate, reportException, shouldEmitMcpTelemetry, } from '../../telemetry/index.js';
+import { collectTelemetryRedactionSecrets } from '../../telemetry/redaction-secrets.js';
 import { scrubErrorClass } from '../../telemetry/scrubber.js';
 const connectionIdSchema = z.string().min(1);
 const unknownRecordSchema = z.record(z.string(), z.unknown());
@@ -405,12 +406,26 @@ function mcpProgressCallback(context) {
         });
     };
 }
-function registerParsedTool(server, name, config, schema, handler) {
+function registerParsedTool(server, name, config, schema, handler, telemetry) {
     server.registerTool(name, config, async (input, context) => {
         try {
             return await handler(schema.parse(input), context);
         }
         catch (error) {
+            if (telemetry?.io) {
+                await reportException({
+                    error,
+                    context: { source: `mcp:${name}`, handled: true, fatal: false },
+                    projectDir: telemetry.projectDir,
+                    io: telemetry.io,
+                    redactionSecrets: await collectTelemetryRedactionSecrets({
+                        projectDir: telemetry.projectDir,
+                        includeLlm: true,
+                        includeEmbeddings: true,
+                        env: process.env,
+                    }),
+                });
+            }
             return jsonErrorToolResult(formatToolError(error));
         }
     });
@@ -452,6 +467,20 @@ function instrumentMcpServer(server, telemetry) {
                     return result;
                 }
                 catch (error) {
+                    if (telemetry.io) {
+                        await reportException({
+                            error,
+                            context: { source: `mcp:${name}`, handled: true, fatal: false },
+                            projectDir: telemetry.projectDir,
+                            io: telemetry.io,
+                            redactionSecrets: await collectTelemetryRedactionSecrets({
+                                projectDir: telemetry.projectDir,
+                                includeLlm: true,
+                                includeEmbeddings: true,
+                                env: process.env,
+                            }),
+                        });
+                    }
                     if (telemetry.io && telemetry.projectDir && shouldEmitMcpTelemetry()) {
                         const errorClass = scrubErrorClass(error);
                         await emitTelemetryEvent({
@@ -476,6 +505,7 @@ function instrumentMcpServer(server, telemetry) {
 }
 export function registerKtxContextTools(deps) {
     const { ports, userContext } = deps;
+    const toolTelemetry = { projectDir: deps.projectDir, io: deps.io };
     const server = instrumentMcpServer(deps.server, {
         projectDir: deps.projectDir,
         io: deps.io,
@@ -489,7 +519,7 @@ export function registerKtxContextTools(deps) {
             inputSchema: connectionListSchema.shape,
             outputSchema: connectionListOutputSchema,
             annotations: toolAnnotations.connection_list,
-        }, connectionListSchema, async () => jsonToolResult({ connections: await connections.list() }));
+        }, connectionListSchema, async () => jsonToolResult({ connections: await connections.list() }), toolTelemetry);
     }
     if (ports.knowledge) {
         const knowledge = ports.knowledge;
@@ -503,7 +533,7 @@ export function registerKtxContextTools(deps) {
             userId: userContext.userId,
             query: input.query,
             limit: input.limit,
-        })));
+        })), toolTelemetry);
         registerParsedTool(server, 'wiki_read', {
             title: toolAnnotations.wiki_read.title,
             description: toolDescriptions.wiki_read,
@@ -513,7 +543,7 @@ export function registerKtxContextTools(deps) {
         }, knowledgeReadSchema, async (input) => {
             const page = await knowledge.read({ userId: userContext.userId, key: input.key });
             return page ? jsonToolResult(page) : jsonErrorToolResult(`Wiki page "${input.key}" was not found.`);
-        });
+        }, toolTelemetry);
     }
     if (ports.semanticLayer) {
         const semanticLayer = ports.semanticLayer;
@@ -528,7 +558,7 @@ export function registerKtxContextTools(deps) {
             return source
                 ? jsonToolResult(source)
                 : jsonErrorToolResult(`Semantic-layer source "${input.sourceName}" was not found.`);
-        });
+        }, toolTelemetry);
         registerParsedTool(server, 'sl_query', {
             title: toolAnnotations.sl_query.title,
             description: toolDescriptions.sl_query,
@@ -550,7 +580,7 @@ export function registerKtxContextTools(deps) {
                 },
             }, onProgress ? { onProgress } : undefined);
             return jsonToolResult(projectSlQueryResult(result, input.include));
-        });
+        }, toolTelemetry);
     }
     if (ports.entityDetails) {
         const entityDetails = ports.entityDetails;
@@ -560,7 +590,7 @@ export function registerKtxContextTools(deps) {
             inputSchema: entityDetailsSchema.shape,
             outputSchema: entityDetailsOutputSchema,
             annotations: toolAnnotations.entity_details,
-        }, entityDetailsSchema, async (input) => jsonToolResult(await entityDetails.read(input)));
+        }, entityDetailsSchema, async (input) => jsonToolResult(await entityDetails.read(input)), toolTelemetry);
     }
     if (ports.dictionarySearch) {
         const dictionarySearch = ports.dictionarySearch;
@@ -570,7 +600,7 @@ export function registerKtxContextTools(deps) {
             inputSchema: dictionarySearchSchema.shape,
             outputSchema: dictionarySearchOutputSchema,
             annotations: toolAnnotations.dictionary_search,
-        }, dictionarySearchSchema, async (input) => jsonToolResult(await dictionarySearch.search(input)));
+        }, dictionarySearchSchema, async (input) => jsonToolResult(await dictionarySearch.search(input)), toolTelemetry);
     }
     if (ports.discover) {
         const discover = ports.discover;
@@ -580,7 +610,7 @@ export function registerKtxContextTools(deps) {
             inputSchema: discoverDataSchema.shape,
             outputSchema: discoverDataOutputSchema,
             annotations: toolAnnotations.discover_data,
-        }, discoverDataSchema, async (input) => jsonToolResult({ refs: await discover.search(input) }));
+        }, discoverDataSchema, async (input) => jsonToolResult({ refs: await discover.search(input) }), toolTelemetry);
     }
     if (ports.sqlExecution) {
         const sqlExecution = ports.sqlExecution;
@@ -597,7 +627,7 @@ export function registerKtxContextTools(deps) {
                 sql: input.sql,
                 maxRows: input.maxRows ?? 1000,
             }, onProgress ? { onProgress } : undefined));
-        });
+        }, toolTelemetry);
     }
     if (ports.memoryIngest) {
         const memoryIngest = ports.memoryIngest;
@@ -617,7 +647,7 @@ export function registerKtxContextTools(deps) {
                 sourceType: 'external_ingest',
             };
             return jsonToolResult(await memoryIngest.ingest(ingestInput));
-        });
+        }, toolTelemetry);
         registerParsedTool(server, 'memory_ingest_status', {
             title: toolAnnotations.memory_ingest_status.title,
             description: toolDescriptions.memory_ingest_status,
@@ -627,6 +657,6 @@ export function registerKtxContextTools(deps) {
         }, memoryIngestStatusSchema, async (input) => {
             const status = await memoryIngest.status(input.runId);
             return status ? jsonToolResult(status) : jsonErrorToolResult(`Memory ingest run "${input.runId}" was not found.`);
-        });
+        }, toolTelemetry);
     }
 }

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

@@ -397,6 +397,18 @@ declare const ktxProjectConfigSchema: z.ZodObject<{
                 continue: "continue";
             }>>;
         }, z.core.$strict>>;
+        rateLimit: z.ZodPrefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            throttleThreshold: z.ZodDefault<z.ZodNumber>;
+            minConcurrencyUnderPressure: z.ZodDefault<z.ZodInt>;
+            maxWaitMs: z.ZodOptional<z.ZodInt>;
+            retry: z.ZodPrefault<z.ZodObject<{
+                maxAttempts: z.ZodDefault<z.ZodInt>;
+                baseDelayMs: z.ZodDefault<z.ZodInt>;
+                maxDelayMs: z.ZodDefault<z.ZodInt>;
+                jitter: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
         profile: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"json">]>>;
     }, z.core.$strict>>;
     agent: z.ZodPrefault<z.ZodObject<{

package/dist/context/project/config.js

@@ -86,6 +86,40 @@ const workUnitsSchema = z
         .describe('Behavior when a work unit fails: "abort" stops the whole ingest run; "continue" records the failure and keeps going.'),
 })
     .describe('Concurrency and failure handling for ingest work units.');
+const ingestRateLimitRetrySchema = z
+    .strictObject({
+    maxAttempts: z
+        .int()
+        .positive()
+        .default(6)
+        .describe('Maximum attempts for a single rate-limited LLM call before the failure surfaces, counting the first try. Also bounds how far opaque backoff grows for providers that do not expose a reset time.'),
+    baseDelayMs: z.int().positive().default(1_000).describe('Initial opaque retry delay in milliseconds.'),
+    maxDelayMs: z.int().positive().default(60_000).describe('Maximum opaque retry delay in milliseconds.'),
+    jitter: z.boolean().default(true).describe('When true, apply bounded jitter to opaque retry delays.'),
+})
+    .describe('Retry policy for rate-limit responses that do not include a reset time or retry-after value.');
+const ingestRateLimitSchema = z
+    .strictObject({
+    enabled: z.boolean().default(true).describe('Master switch for ingest LLM rate-limit pacing and visible waits.'),
+    throttleThreshold: z
+        .number()
+        .min(0)
+        .max(1)
+        .default(0.8)
+        .describe('Provider utilization at or above which ingest throttles new work-unit starts.'),
+    minConcurrencyUnderPressure: z
+        .int()
+        .positive()
+        .default(1)
+        .describe('Effective work-unit concurrency while a provider is under rate-limit pressure.'),
+    maxWaitMs: z
+        .int()
+        .positive()
+        .optional()
+        .describe('Optional cap on a single provider reset wait. Omit to wait indefinitely until the provider reset time.'),
+    retry: ingestRateLimitRetrySchema.prefault({}).describe('Opaque retry policy for providers without reset hints.'),
+})
+    .describe('Rate-limit pacing and wait policy for ingest LLM calls.');
 const ingestSchema = z
     .strictObject({
     adapters: z
@@ -96,6 +130,7 @@ const ingestSchema = z
         .prefault({ backend: 'none' })
         .describe('Embedding configuration used when ingest adapters need to embed documents.'),
     workUnits: workUnitsSchema.prefault({}).describe('Concurrency and failure handling for ingest work units.'),
+    rateLimit: ingestRateLimitSchema.prefault({}).describe('LLM rate-limit pacing and visible-wait policy for ingest.'),
     profile: z
         .union([z.boolean(), z.literal('json')])
         .default(false)

package/dist/context/scan/types.d.ts

@@ -233,10 +233,23 @@ export interface KtxTableListEntry {
     name: string;
     kind: 'table' | 'view';
 }
-interface KtxConnectorTestResult {
+export interface KtxConnectorTestResult {
     success: boolean;
     error?: string;
-}
+    /**
+     * The original error thrown by the driver, preserved unflattened so the
+     * connection-test path can re-throw it. Keeping the real error object lets
+     * telemetry record the driver's actual error class (e.g. `ConnectionError`)
+     * and `.code` (e.g. `ELOGIN`) instead of collapsing every failure to `Error`.
+     */
+    cause?: unknown;
+}
+/**
+ * Single source of truth for a failed connector test result. Captures the
+ * driver's message for display while preserving the original error as `cause`
+ * so callers can surface its real class and code.
+ */
+export declare function connectorTestFailure(error: unknown): KtxConnectorTestResult;
 export interface KtxScanConnector {
     id: string;
     driver: KtxConnectionDriver;

package/dist/context/scan/types.js

@@ -11,3 +11,15 @@ export function createKtxConnectorCapabilities(capabilities = {}) {
         estimatedRowCounts: capabilities.estimatedRowCounts ?? false,
     };
 }
+/**
+ * Single source of truth for a failed connector test result. Captures the
+ * driver's message for display while preserving the original error as `cause`
+ * so callers can surface its real class and code.
+ */
+export function connectorTestFailure(error) {
+    return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        cause: error,
+    };
+}

package/dist/context/sl/description-normalization.js

@@ -39,12 +39,6 @@ function humanizeIdentifier(value) {
         .trim()
         .toLowerCase();
 }
-function formatCount(count, singular, plural = `${singular}s`) {
-    if (count <= 0) {
-        return null;
-    }
-    return `${count} ${count === 1 ? singular : plural}`;
-}
 function sourceFallback(source, sourceName) {
     const table = cleanText(source.table);
     const sql = cleanText(source.sql);
@@ -54,14 +48,10 @@ function sourceFallback(source, sourceName) {
     if (sql) {
         return `Semantic-layer source for ${sourceName} backed by curated SQL.`;
     }
-    const counts = [
-        formatCount(Array.isArray(source.measures) ? source.measures.length : 0, 'measure'),
-        formatCount(Array.isArray(source.segments) ? source.segments.length : 0, 'segment'),
-        formatCount(Array.isArray(source.columns) ? source.columns.length : 0, 'computed column'),
-    ].filter((item) => Boolean(item));
-    return counts.length > 0
-        ? `Semantic-layer overlay for ${sourceName} defining ${counts.join(', ')}.`
-        : `Semantic-layer overlay for ${sourceName}.`;
+    // Measure/segment/column counts are rendered live from the body at list/read
+    // time, so baking them into stored prose freezes a derived value that drifts
+    // as the source later gains measures. Keep the auto fallback count-free.
+    return `Semantic-layer overlay for ${sourceName}.`;
 }
 function columnFallback(column, sourceName) {
     const columnName = cleanText(column.name) ?? 'column';

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

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

package/dist/context-build-view.d.ts

@@ -2,6 +2,7 @@ import type { KtxCliIo } from './index.js';
 import type { KtxManagedPythonInstallPolicy } from './managed-python-command.js';
 import type { KtxPublicIngestArgs, KtxPublicIngestPlanTarget, KtxPublicIngestProject } from './public-ingest.js';
 import { executePublicIngestTarget } from './public-ingest.js';
+import { fetchGitHubStarCount as defaultFetchGitHubStarCount } from './star-prompt/star-count.js';
 type PhaseKey = 'database-schema' | 'query-history' | 'source-ingest';
 type PhaseStatus = 'queued' | 'running' | 'done' | 'failed' | 'skipped';
 interface PhaseState {
@@ -32,6 +33,7 @@ export interface ContextBuildViewState {
     frame: number;
     startedAt: number | null;
     totalElapsedMs: number;
+    starCount: number | null;
 }
 export interface ContextBuildArgs {
     projectDir: string;
@@ -73,6 +75,8 @@ interface CompletedItemName {
 interface ContextBuildRenderOptions {
     styled?: boolean;
     showHint?: boolean;
+    showStarPrompt?: boolean;
+    columns?: number;
     hintText?: string;
     projectDir?: string;
     title?: string;
@@ -89,6 +93,14 @@ export interface ContextBuildDeps {
     now?: () => number;
     onSourceProgress?: (sources: ContextBuildSourceProgressUpdate[]) => void;
     sourceProgressThrottleMs?: number;
+    fetchStarCount?: typeof defaultFetchGitHubStarCount;
+    starPromptEnv?: StarPromptEnv;
+    starPromptHomeDir?: string;
+}
+interface StarPromptEnv extends NodeJS.ProcessEnv {
+    CI?: string;
+    DO_NOT_TRACK?: string;
+    KTX_NO_STAR?: string;
 }
 export declare function renderContextBuildView(state: ContextBuildViewState, options?: ContextBuildRenderOptions): string;
 /** @internal */
@@ -101,6 +113,7 @@ export declare function parseIngestSummary(output: string): string | null;
 export declare function viewStateFromSourceProgress(sources: ContextBuildSourceProgressUpdate[], now: number, startedAtMs?: number): ContextBuildViewState;
 export declare function createRepainter(io: KtxCliIo): {
     paint(content: string): void;
+    columns(): number;
 };
 export declare function initViewState(targets: KtxPublicIngestPlanTarget[]): ContextBuildViewState;
 export declare function runContextBuild(project: KtxPublicIngestProject, args: ContextBuildArgs, io: KtxCliIo, deps?: ContextBuildDeps): Promise<ContextBuildResult>;

package/dist/context-build-view.js

@@ -2,6 +2,9 @@ import { buildPublicIngestPlan, executePublicIngestTarget, publicProgressMessage
 import { createAggregateProgressPort } from './progress-port-adapter.js';
 import { formatDuration } from './demo-metrics.js';
 import { profileMark } from './startup-profile.js';
+import { isFreshStarCountCache, readStarCountCache, writeStarCountCache, } from './star-prompt/cache.js';
+import { fetchGitHubStarCount as defaultFetchGitHubStarCount } from './star-prompt/star-count.js';
+import { renderStarPromptLine } from './star-prompt/star-line.js';
 profileMark('module:context-build-view');
 const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 const ESC = String.fromCharCode(0x1b);
@@ -286,6 +289,13 @@ export function renderContextBuildView(state, options = {}) {
         lines.push(styled ? green(summary) : summary);
         lines.push('');
     }
+    if (options.showStarPrompt && hasActive) {
+        const starPrompt = renderStarPromptLine({
+            count: state.starCount,
+            columns: options.columns ?? 80,
+        });
+        lines.push(styled ? dim(starPrompt) : starPrompt);
+    }
     if (options.showHint && hasActive) {
         const hintContent = options.hintText ?? 'Ctrl+C to stop';
         const hint = `  ${hintContent}`;
@@ -423,6 +433,7 @@ export function viewStateFromSourceProgress(sources, now, startedAtMs) {
         frame: 0,
         startedAt: startedAtMs ?? null,
         totalElapsedMs: startedAtMs ? now - startedAtMs : 0,
+        starCount: null,
     };
 }
 // --- Repaint ---
@@ -465,6 +476,9 @@ export function createRepainter(io) {
             hasPainted = true;
             lastCursorUpRows = cursorUpRowsAfterWrite(content);
         },
+        columns() {
+            return terminalColumns();
+        },
     };
 }
 // --- Orchestration ---
@@ -616,12 +630,42 @@ export function initViewState(targets) {
         frame: 0,
         startedAt: null,
         totalElapsedMs: 0,
+        starCount: null,
     };
 }
 function formatProgressDetail(update, target) {
     const percent = Math.max(0, Math.min(100, Math.round(update.percent)));
     return `[${percent}%] ${publicProgressMessage(update.message, target)}`;
 }
+const STAR_COUNT_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+function envFlag(value) {
+    return value !== undefined && value !== '' && value !== '0' && value !== 'false';
+}
+function shouldSuppressStarPrompt(env) {
+    return envFlag(env.CI) || envFlag(env.DO_NOT_TRACK) || envFlag(env.KTX_NO_STAR);
+}
+function startStarPromptCountRefresh(input) {
+    const cached = readStarCountCache({ homeDir: input.homeDir });
+    if (cached) {
+        input.state.starCount = cached.count;
+    }
+    if (isFreshStarCountCache(cached, new Date(input.now()), STAR_COUNT_CACHE_TTL_MS)) {
+        return;
+    }
+    void input.fetchStarCount()
+        .then((count) => {
+        if (typeof count !== 'number' || !Number.isFinite(count)) {
+            return;
+        }
+        input.state.starCount = count;
+        input.paint();
+        void writeStarCountCache({
+            count,
+            fetchedAt: new Date(input.now()).toISOString(),
+        }, { homeDir: input.homeDir });
+    })
+        .catch(() => undefined);
+}
 export async function runContextBuild(project, args, io, deps = {}) {
     const plan = buildPublicIngestPlan(project, {
         projectDir: args.projectDir,
@@ -636,13 +680,28 @@ export async function runContextBuild(project, args, io, deps = {}) {
     const nowFn = deps.now ?? (() => Date.now());
     state.startedAt = nowFn();
     const repainter = isTTY ? createRepainter(io) : null;
+    const starPromptEnabled = repainter !== null && !shouldSuppressStarPrompt(deps.starPromptEnv ?? process.env);
     const viewOpts = {
         styled: true,
         projectDir: args.projectDir,
         notices: plan.notices ?? [],
         warnings: plan.warnings,
     };
-    const paint = (hint) => repainter?.paint(renderContextBuildView(state, { ...viewOpts, showHint: hint }));
+    const paint = (hint) => repainter?.paint(renderContextBuildView(state, {
+        ...viewOpts,
+        showHint: hint,
+        showStarPrompt: starPromptEnabled && hint,
+        columns: repainter.columns(),
+    }));
+    if (starPromptEnabled) {
+        startStarPromptCountRefresh({
+            fetchStarCount: deps.fetchStarCount ?? defaultFetchGitHubStarCount,
+            homeDir: deps.starPromptHomeDir,
+            now: nowFn,
+            paint: () => paint(true),
+            state,
+        });
+    }
     paint(true);
     let spinnerInterval = null;
     if (repainter) {

package/dist/demo-metrics.d.ts

@@ -8,8 +8,6 @@ interface DemoMetricsTuning {
 interface DemoMetricsSnapshot {
     elapsedMs: number;
     etaMs: number | null;
-    agentSteps: number;
-    agentStepBudget: number;
     toolCalls: number;
     workUnitsStarted: number;
     workUnitsFinished: number;

package/dist/demo-metrics.js

@@ -5,13 +5,6 @@ const DEFAULT_OUTPUT_PRICE_PER_MTOK_USD = 15;
 function eventsOf(events, type) {
     return events.filter((event) => event.type === type);
 }
-function maxAgentStep(events) {
-    const steps = eventsOf(events, 'work_unit_step');
-    const started = eventsOf(events, 'work_unit_started');
-    const stepIndex = steps.reduce((max, event) => Math.max(max, event.stepIndex), 0);
-    const stepBudget = Math.max(0, ...steps.map((event) => event.stepBudget), ...started.map((event) => event.stepBudget));
-    return { step: stepIndex, budget: stepBudget };
-}
 function totalToolCalls(input) {
     return input.details.transcripts.reduce((total, transcript) => total + transcript.toolCallCount, 0);
 }
@@ -49,11 +42,10 @@ export function buildDemoMetrics(input, options = {}) {
     const outputPrice = tuning.outputPricePerMTokUsd ?? DEFAULT_OUTPUT_PRICE_PER_MTOK_USD;
     const nowMs = (options.now ?? Date.now)();
     const elapsedMs = elapsedMsFromEvents(input.events, nowMs);
-    const { step, budget } = maxAgentStep(input.events);
     const toolCalls = totalToolCalls(input);
     const progress = workUnitProgress(input);
     const finishedCount = eventsOf(input.events, 'work_unit_finished').length;
-    const stepDriver = Math.max(step, toolCalls, finishedCount * 4);
+    const stepDriver = Math.max(toolCalls, finishedCount * 4);
     const inputTokens = stepDriver * inputTokensPerStep;
     const outputTokens = stepDriver * outputTokensPerStep;
     const totalTokens = inputTokens + outputTokens;
@@ -63,8 +55,6 @@ export function buildDemoMetrics(input, options = {}) {
     return {
         elapsedMs,
         etaMs: estimateEtaMs(elapsedMs, progress.finished, progress.total, input.status),
-        agentSteps: step,
-        agentStepBudget: budget,
         toolCalls,
         workUnitsStarted: progress.started,
         workUnitsFinished: progress.finished,

package/dist/ingest.d.ts

@@ -58,6 +58,7 @@ export interface KtxIngestDeps {
     readReportFile?: typeof readIngestReportSnapshotFile;
     renderStoredMemoryFlow?: typeof renderMemoryFlowTui;
     startLiveMemoryFlow?: typeof startLiveMemoryFlowTui;
+    abortSignal?: AbortSignal;
     env?: NodeJS.ProcessEnv;
     localIngestOptions?: Pick<RunLocalIngestOptions, 'agentRunner' | 'llmRuntime' | 'memoryModel' | 'semanticLayerCompute' | 'queryExecutor' | 'logger' | 'pullConfigOptions'>;
     progress?: (update: KtxIngestProgressUpdate) => void;