@kaelio/ktx 0.9.0 → 0.10.0

package/dist/connectors/sqlserver/connector.d.ts

@@ -1,4 +1,4 @@
-import { type KtxColumnSampleInput, type KtxColumnSampleResult, type KtxColumnStatsInput, type KtxColumnStatsResult, type KtxQueryResult, type KtxReadOnlyQueryInput, type KtxScanConnector, type KtxScanContext, type KtxScanInput, type KtxSchemaSnapshot, type KtxTableListEntry, type KtxTableRef, type KtxTableSampleInput, type KtxTableSampleResult } from '../../context/scan/types.js';
+import { type KtxConnectorTestResult, type KtxColumnSampleInput, type KtxColumnSampleResult, type KtxColumnStatsInput, type KtxColumnStatsResult, type KtxQueryResult, type KtxReadOnlyQueryInput, type KtxScanConnector, type KtxScanContext, type KtxScanInput, type KtxSchemaSnapshot, type KtxTableListEntry, type KtxTableRef, type KtxTableSampleInput, type KtxTableSampleResult } from '../../context/scan/types.js';
 export interface KtxSqlServerConnectionConfig {
     driver?: string;
     host?: string;
@@ -113,10 +113,7 @@ export declare class KtxSqlServerScanConnector implements KtxScanConnector {
     private pool;
     private resolvedEndpoint;
     constructor(options: KtxSqlServerScanConnectorOptions);
-    testConnection(): Promise<{
-        success: boolean;
-        error?: string;
-    }>;
+    testConnection(): Promise<KtxConnectorTestResult>;
     introspect(input: KtxScanInput, _ctx: KtxScanContext): Promise<KtxSchemaSnapshot>;
     sampleTable(input: KtxTableSampleInput, _ctx: KtxScanContext): Promise<KtxSqlServerTableSampleResult>;
     sampleColumn(input: KtxColumnSampleInput, _ctx: KtxScanContext): Promise<KtxColumnSampleResult>;

package/dist/connectors/sqlserver/connector.js

@@ -2,7 +2,7 @@ import { assertReadOnlySql } from '../../context/connections/read-only-sql.js';
 import { getDialectForDriver } from '../../context/connections/dialects.js';
 import { tryConstraintQuery } from '../../context/scan/constraint-discovery.js';
 import { scopedTableNames } from '../../context/scan/table-ref.js';
-import { createKtxConnectorCapabilities, } from '../../context/scan/types.js';
+import { connectorTestFailure, createKtxConnectorCapabilities, } from '../../context/scan/types.js';
 import { readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { resolve } from 'node:path';
@@ -235,7 +235,7 @@ export class KtxSqlServerScanConnector {
             return { success: true };
         }
         catch (error) {
-            return { success: false, error: error instanceof Error ? error.message : String(error) };
+            return connectorTestFailure(error);
         }
     }
     async introspect(input, _ctx) {

package/dist/context/connections/drivers.d.ts

@@ -14,7 +14,6 @@ export interface KtxDriverRegistration {
     readonly driver: KtxConnectionDriver;
     readonly scopeConfigKey: KtxScopeConfigKey | null;
     readonly hasHistoricSqlReader: boolean;
-    readonly hasLocalQueryExecutor: boolean;
     load(): Promise<KtxDriverConnectorModule>;
 }
 /** @internal */

package/dist/context/connections/drivers.js

@@ -7,7 +7,6 @@ export const driverRegistrations = {
         driver: 'bigquery',
         scopeConfigKey: 'dataset_ids',
         hasHistoricSqlReader: true,
-        hasLocalQueryExecutor: false,
         load: async () => {
             const m = await import('../../connectors/bigquery/connector.js');
             return {
@@ -29,7 +28,6 @@ export const driverRegistrations = {
         driver: 'clickhouse',
         scopeConfigKey: 'databases',
         hasHistoricSqlReader: false,
-        hasLocalQueryExecutor: false,
         load: async () => {
             const m = await import('../../connectors/clickhouse/connector.js');
             return {
@@ -51,7 +49,6 @@ export const driverRegistrations = {
         driver: 'mysql',
         scopeConfigKey: 'schemas',
         hasHistoricSqlReader: false,
-        hasLocalQueryExecutor: false,
         load: async () => {
             const m = await import('../../connectors/mysql/connector.js');
             return {
@@ -73,7 +70,6 @@ export const driverRegistrations = {
         driver: 'postgres',
         scopeConfigKey: 'schemas',
         hasHistoricSqlReader: true,
-        hasLocalQueryExecutor: true,
         load: async () => {
             const m = await import('../../connectors/postgres/connector.js');
             return {
@@ -95,7 +91,6 @@ export const driverRegistrations = {
         driver: 'sqlite',
         scopeConfigKey: null,
         hasHistoricSqlReader: false,
-        hasLocalQueryExecutor: true,
         load: async () => {
             const m = await import('../../connectors/sqlite/connector.js');
             return {
@@ -117,7 +112,6 @@ export const driverRegistrations = {
         driver: 'snowflake',
         scopeConfigKey: 'schema_names',
         hasHistoricSqlReader: true,
-        hasLocalQueryExecutor: false,
         load: async () => {
             const m = await import('../../connectors/snowflake/connector.js');
             return {
@@ -139,7 +133,6 @@ export const driverRegistrations = {
         driver: 'sqlserver',
         scopeConfigKey: 'schemas',
         hasHistoricSqlReader: false,
-        hasLocalQueryExecutor: false,
         load: async () => {
             const m = await import('../../connectors/sqlserver/connector.js');
             return {

package/dist/context/connections/query-executor.d.ts

@@ -6,7 +6,7 @@ export interface KtxSqlQueryExecutionInput {
     sql: string;
     maxRows?: number;
 }
-export interface KtxSqlQueryExecutionResult {
+interface KtxSqlQueryExecutionResult {
     headers: string[];
     rows: unknown[][];
     totalRows: number;
@@ -17,3 +17,4 @@ export interface KtxSqlQueryExecutorPort {
     execute(input: KtxSqlQueryExecutionInput): Promise<KtxSqlQueryExecutionResult>;
 }
 export declare function normalizeQueryRows(rows: unknown[]): unknown[][];
+export {};

package/dist/context/core/abort.d.ts

@@ -0,0 +1,9 @@
+/** @internal */
+export declare function createAbortError(message?: string): DOMException;
+export declare function isAbortError(error: unknown): boolean;
+/** @internal */
+export declare function throwIfAborted(signal?: AbortSignal): void;
+export declare function linkAbortSignal(parent?: AbortSignal): {
+    controller: AbortController;
+    dispose: () => void;
+};

package/dist/context/core/abort.js

@@ -0,0 +1,36 @@
+/** @internal */
+export function createAbortError(message = 'Aborted') {
+    return new DOMException(message, 'AbortError');
+}
+export function isAbortError(error) {
+    if (error instanceof DOMException && error.name === 'AbortError') {
+        return true;
+    }
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const record = error;
+    return record.name === 'AbortError' || record.code === 'ABORT_ERR';
+}
+/** @internal */
+export function throwIfAborted(signal) {
+    if (signal?.aborted) {
+        throw createAbortError();
+    }
+}
+export function linkAbortSignal(parent) {
+    const controller = new AbortController();
+    if (!parent) {
+        return { controller, dispose: () => undefined };
+    }
+    if (parent.aborted) {
+        controller.abort(createAbortError());
+        return { controller, dispose: () => undefined };
+    }
+    const onAbort = () => controller.abort(createAbortError());
+    parent.addEventListener('abort', onAbort, { once: true });
+    return {
+        controller,
+        dispose: () => parent.removeEventListener('abort', onAbort),
+    };
+}

package/dist/context/ingest/adapters/historic-sql/query-history-filter-picker.d.ts

@@ -12,6 +12,7 @@ export interface QueryHistoryFilterProposal {
         reason: 'no-llm' | 'no-daemon' | 'no-in-scope-history' | 'user-block-present';
     } | null;
     warnings: string[];
+    parseFailedTemplateIds: string[];
 }
 export interface ProposeQueryHistoryServiceAccountFiltersInput {
     connectionId: string;

package/dist/context/ingest/adapters/historic-sql/query-history-filter-picker.js

@@ -12,7 +12,7 @@ const queryHistoryFilterAdjudicationSchema = z.object({
     }).strict()),
 }).strict();
 function emptyProposal(skipped, warnings = []) {
-    return { excludedRoles: [], consideredRoleCount: 0, skipped, warnings };
+    return { excludedRoles: [], consideredRoleCount: 0, skipped, warnings, parseFailedTemplateIds: [] };
 }
 function displayTableRef(ref) {
     return [ref.catalog, ref.db, ref.name].filter((part) => !!part && part.length > 0).join('.');
@@ -98,6 +98,7 @@ export async function proposeQueryHistoryServiceAccountFilters(input) {
     const windowDays = 'windowDays' in config ? config.windowDays : 90;
     const windowStart = new Date(now.getTime() - windowDays * 24 * 60 * 60 * 1000);
     const warnings = [];
+    const parseFailedTemplateIds = [];
     const snapshot = [];
     try {
         for await (const row of input.reader.fetchAggregated(input.queryClient, { start: windowStart, end: now }, config)) {
@@ -127,7 +128,7 @@ export async function proposeQueryHistoryServiceAccountFilters(input) {
     for (const template of snapshot) {
         const parsed = analysis.get(template.templateId);
         if (!parsed || parsed.error) {
-            warnings.push(`query_history_filter_picker_parse_failed:${template.templateId}`);
+            parseFailedTemplateIds.push(template.templateId);
             continue;
         }
         const tablesTouched = [...new Map(parsed.tablesTouched.map((ref) => [tableRefKey(ref), ref])).values()]
@@ -150,6 +151,7 @@ export async function proposeQueryHistoryServiceAccountFilters(input) {
             consideredRoleCount: records.length,
             skipped: { reason: 'no-in-scope-history' },
             warnings,
+            parseFailedTemplateIds,
         };
     }
     let generated;
@@ -170,6 +172,7 @@ export async function proposeQueryHistoryServiceAccountFilters(input) {
                 ...warnings,
                 `query_history_filter_picker_llm_failed:${error instanceof Error ? error.message : String(error)}`,
             ],
+            parseFailedTemplateIds,
         };
     }
     const knownRoles = new Set(records.map((record) => record.role));
@@ -186,5 +189,6 @@ export async function proposeQueryHistoryServiceAccountFilters(input) {
         consideredRoleCount: records.length,
         skipped: input.userServiceAccountsPresent ? { reason: 'user-block-present' } : null,
         warnings,
+        parseFailedTemplateIds,
     };
 }

package/dist/context/ingest/context-candidates/curator-pagination.service.d.ts

@@ -31,11 +31,7 @@ export interface CuratorPaginationInput {
     buildUserPrompt: (input: CuratorPaginationPromptInput) => string;
     buildToolSet: (passNumber: number) => KtxRuntimeToolSet;
     getReconciliationActions: () => MemoryAction[];
-    onStepFinish?: (info: {
-        passNumber: number;
-        stepIndex: number;
-        stepBudget: number;
-    }) => void;
+    abortSignal?: AbortSignal;
 }
 interface CuratorPaginationResult extends ReconciliationOutcome {
     report: CuratorPaginationReport;

package/dist/context/ingest/context-candidates/curator-pagination.service.js

@@ -163,9 +163,7 @@ export class CuratorPaginationService {
             sourceKey: params.input.sourceKey,
             jobId: params.input.jobId,
             forceRun: params.forceRun,
-            onStepFinish: params.input.onStepFinish
-                ? ({ stepIndex, stepBudget }) => params.input.onStepFinish?.({ passNumber: params.passNumber, stepIndex, stepBudget })
-                : undefined,
+            abortSignal: params.input.abortSignal,
         });
     }
     batchSummary(items) {

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" | "rejected" | "promoted";
+        status: "conflict" | "merged" | "rejected" | "pending" | "promoted";
         promotionScore: number;
         suggestedPageKey: string | null;
         evidenceRefs: JsonValue;

package/dist/context/ingest/final-gate-repair.d.ts

@@ -20,6 +20,7 @@ export interface RepairFinalGateFailureInput {
     repairKind: FinalGateRepairKind;
     maxAttempts?: number;
     stepBudget?: number;
+    abortSignal?: AbortSignal;
 }
 export declare function finalGateRepairPaths(input: {
     changedWikiPageKeys: string[];

package/dist/context/ingest/final-gate-repair.js

@@ -153,6 +153,7 @@ export async function repairFinalGateFailure(input) {
                 jobId: input.trace.context.jobId,
                 repairKind: input.repairKind,
             },
+            abortSignal: input.abortSignal,
         }));
         if (result.stopReason === 'error') {
             lastFailure = result.error?.message ?? 'gate repair agent loop errored';

package/dist/context/ingest/ingest-bundle.runner.d.ts

@@ -9,6 +9,9 @@ export declare class IngestBundleRunner {
     private readonly chainByConnection;
     constructor(deps: IngestBundleRunnerDeps);
     run(job: IngestBundleJob, ctx?: IngestJobContext): Promise<IngestBundleResult>;
+    private formatRateLimitWait;
+    private subscribeRateLimitGovernor;
+    private withRateLimitWorkSlot;
     /**
      * When profiling is enabled — via the `KTX_PROFILE_INGEST` env var or the
      * `ingest.profile` config setting — read the job's trace + tool transcripts

package/dist/context/ingest/ingest-bundle.runner.js

@@ -115,6 +115,10 @@ export class IngestBundleRunner {
         this.logger = deps.logger ?? noopLogger;
     }
     async run(job, ctx) {
+        const unsubscribeRateLimitGovernor = this.subscribeRateLimitGovernor({
+            trace: this.createTrace(job),
+            memoryFlow: ctx?.memoryFlow,
+        });
         const key = job.connectionId;
         const previous = this.chainByConnection.get(key);
         if (previous) {
@@ -139,9 +143,64 @@ export class IngestBundleRunner {
             throw error;
         }
         finally {
+            unsubscribeRateLimitGovernor();
             await this.maybeEmitIngestProfile(job.jobId);
         }
     }
+    formatRateLimitWait(state) {
+        const seconds = Math.ceil(state.remainingMs / 1_000);
+        const minutes = Math.floor(seconds / 60);
+        const remainder = seconds % 60;
+        const duration = minutes > 0 ? `${minutes}m${String(remainder).padStart(2, '0')}s` : `${seconds}s`;
+        const type = state.rateLimitType ? ` ${state.rateLimitType}` : '';
+        return `Rate-limited (${state.provider}${type}); resuming in ${duration}; Ctrl+C to stop`;
+    }
+    subscribeRateLimitGovernor(input) {
+        const governor = this.deps.settings.rateLimitGovernor;
+        if (!governor) {
+            return () => undefined;
+        }
+        return governor.subscribe((state) => {
+            if (state.kind === 'rate_limit_observed') {
+                void input.trace.event('info', 'rate_limit', 'rate_limit_observed', { ...state });
+                return;
+            }
+            if (state.kind === 'concurrency_adjusted') {
+                void input.trace.event('info', 'rate_limit', 'concurrency_adjusted', { ...state });
+                return;
+            }
+            void input.trace.event('info', 'rate_limit', state.kind, { ...state });
+            if (state.kind === 'wait_tick' || state.kind === 'wait_started') {
+                input.memoryFlow?.emit({
+                    type: 'rate_limit_wait',
+                    provider: state.provider,
+                    ...(state.rateLimitType ? { rateLimitType: state.rateLimitType } : {}),
+                    resumeAtMs: state.resumeAtMs,
+                    remainingMs: state.remainingMs,
+                });
+                input.memoryFlow?.emit({
+                    type: 'stage_progress',
+                    stage: 'integration',
+                    percent: 50,
+                    message: this.formatRateLimitWait(state),
+                    transient: true,
+                });
+            }
+        });
+    }
+    async withRateLimitWorkSlot(abortSignal, fn) {
+        const governor = this.deps.settings.rateLimitGovernor;
+        if (!governor) {
+            return fn();
+        }
+        const release = await governor.acquireWorkSlot(abortSignal);
+        try {
+            return await fn();
+        }
+        finally {
+            release();
+        }
+    }
     /**
      * When profiling is enabled — via the `KTX_PROFILE_INGEST` env var or the
      * `ingest.profile` config setting — read the job's trace + tool transcripts
@@ -711,7 +770,6 @@ export class IngestBundleRunner {
             type: 'work_unit_started',
             unitKey: input.wu.unitKey,
             skills: input.wuSkillNames,
-            stepBudget: input.workUnitSettings.stepBudget,
         });
         return executeWorkUnit({
             sessionWorktreeGit: input.worktree.git,
@@ -731,14 +789,30 @@ export class IngestBundleRunner {
                 slIndex: input.slIndex,
                 priorProvenance: input.priorProvenance,
             }),
-            buildToolSet: (wuInner) => wrapToolsWithLogger(buildWuToolSet({
-                sourceKey: input.job.sourceKey,
-                stagedDir: input.stagedDir,
-                wu: wuInner,
-                loadSkillTool,
-                emitUnmappedFallbackTool: wuEmitUnmappedFallbackTool,
-                toolsetTools: wuToolset.toRuntimeTools(wuToolContext),
-            }), join(input.transcriptDir, `${wuInner.unitKey}.jsonl`), wuInner.unitKey, { onEntry: input.recordTranscriptEntry(join(input.transcriptDir, `${wuInner.unitKey}.jsonl`)) }),
+            buildToolSet: (wuInner) => {
+                const transcriptPath = join(input.transcriptDir, `${wuInner.unitKey}.jsonl`);
+                const record = input.recordTranscriptEntry(transcriptPath);
+                return wrapToolsWithLogger(buildWuToolSet({
+                    sourceKey: input.job.sourceKey,
+                    stagedDir: input.stagedDir,
+                    wu: wuInner,
+                    loadSkillTool,
+                    emitUnmappedFallbackTool: wuEmitUnmappedFallbackTool,
+                    toolsetTools: wuToolset.toRuntimeTools(wuToolContext),
+                }), transcriptPath, wuInner.unitKey, {
+                    // Drive the live HUD heartbeat from real tool calls: each invocation
+                    // ticks the running per-unit count. This is an observed signal, not a
+                    // re-derived turn count, so it can never overshoot a budget.
+                    onEntry: (entry) => {
+                        const summary = record(entry);
+                        input.memoryFlow?.emit({
+                            type: 'work_unit_step',
+                            unitKey: wuInner.unitKey,
+                            toolCalls: summary.toolCallCount,
+                        });
+                    },
+                });
+            },
             captureSession: session,
             sessionActions,
             modelRole: 'candidateExtraction',
@@ -747,7 +821,7 @@ export class IngestBundleRunner {
             connectionId: input.job.connectionId,
             jobId: input.job.jobId,
             toolFailureCount: (unitKey) => input.transcriptSummaries.get(unitKey)?.fatalErrorCount ?? 0,
-            onStepFinish: input.onStepFinish,
+            abortSignal: input.abortSignal,
         }, input.wu);
     }
     async runInner(job, ctx) {
@@ -797,6 +871,7 @@ export class IngestBundleRunner {
                 const current = transcriptSummaries.get(entry.wuKey) ?? createMutableToolTranscriptSummary(entry.wuKey, path);
                 recordToolTranscriptEntry(current, entry);
                 transcriptSummaries.set(entry.wuKey, current);
+                return current;
             };
             const overrideReport = await this.loadOverrideReport(job);
             const stage1 = ctx?.startPhase(0.08);
@@ -1111,7 +1186,7 @@ export class IngestBundleRunner {
                         await stage3?.updateProgress(1.0, '0 of 0 work units complete');
                     }
                     try {
-                        await Promise.all(workUnits.map((wu, index) => limitWorkUnit(async () => {
+                        await Promise.all(workUnits.map((wu, index) => limitWorkUnit(() => this.withRateLimitWorkSlot(ctx?.abortSignal, async () => {
                             const outcome = await runIsolatedWorkUnit({
                                 unitIndex: index,
                                 ingestionBaseSha,
@@ -1119,6 +1194,7 @@ export class IngestBundleRunner {
                                 patchDir,
                                 trace: runTrace,
                                 workUnit: wu,
+                                abortSignal: ctx?.abortSignal,
                                 afterSuccess: (child) => copyTransientIngestEvidence(child.workdir, sessionWorktree.workdir),
                                 run: async (child) => {
                                     const scopedWikiService = this.deps.wikiService.forWorktree(child.workdir);
@@ -1147,11 +1223,9 @@ export class IngestBundleRunner {
                                         stageIndex,
                                         includeContextEvidenceTools: adapter.evidenceIndexing === 'documents' && !!contextReport,
                                         currentTableExists: (tableRef) => this.tableRefExistsInSemanticLayer(scopedSemanticLayerService, slConnectionIds, tableRef),
+                                        abortSignal: ctx?.abortSignal,
                                         memoryFlow,
                                         wuSkillNames,
-                                        onStepFinish: ({ stepIndex, stepBudget }) => {
-                                            memoryFlow?.emit({ type: 'work_unit_step', unitKey: wu.unitKey, stepIndex, stepBudget });
-                                        },
                                     });
                                 },
                             });
@@ -1173,7 +1247,7 @@ export class IngestBundleRunner {
                             });
                             completedWorkUnits += 1;
                             await stage3?.updateProgress(completedWorkUnits / workUnits.length, `${completedWorkUnits} of ${workUnits.length} work units complete`);
-                        })));
+                        }))));
                     }
                     catch (error) {
                         await this.deps.runs.markFailed(runRow.id);
@@ -1250,6 +1324,7 @@ export class IngestBundleRunner {
                                     reason: context.reason,
                                     maxAttempts: 1,
                                     stepBudget: 12,
+                                    abortSignal: ctx?.abortSignal,
                                 });
                                 emitStageProgress('integration', 82, result.status === 'repaired'
                                     ? `Resolved text conflict for ${context.unitKey}`
@@ -1267,6 +1342,7 @@ export class IngestBundleRunner {
                                     repairKind: 'patch_semantic_gate',
                                     maxAttempts: 1,
                                     stepBudget: 16,
+                                    abortSignal: ctx?.abortSignal,
                                 });
                                 emitStageProgress('integration', 83, result.status === 'repaired'
                                     ? `Repaired semantic gate for ${context.unitKey}`
@@ -1451,6 +1527,37 @@ export class IngestBundleRunner {
                 let curatorReport = null;
                 let curatorWarnings = [];
                 let reconcileOutcome;
+                // Reconcile shares the work-unit liveness model: the HUD heartbeat is driven
+                // by real tool calls (a monotonic, observed count), not a re-derived turn
+                // counter. The soft cap only paces the phase progress bar; it is never shown
+                // to the user, so it cannot read as a misleading "X/Y" fraction.
+                const reconcileTranscriptPath = join(transcriptDir, 'reconcile.jsonl');
+                const reconcileProgressSoftCap = 40;
+                const buildReconcileToolSetWithHeartbeat = () => {
+                    const record = recordTranscriptEntry(reconcileTranscriptPath);
+                    return wrapToolsWithLogger(buildReconcileToolSet({
+                        loadSkillTool: rcLoadSkill,
+                        stageListTool: rcStageListTool,
+                        stageDiffTool: rcStageDiffTool,
+                        evictionListTool: rcEvictionListTool,
+                        emitConflictResolutionTool: rcEmitConflictResolutionTool,
+                        emitEvictionDecisionTool: rcEmitEvictionDecisionTool,
+                        emitArtifactResolutionTool: rcEmitArtifactResolutionTool,
+                        emitUnmappedFallbackTool: rcEmitUnmappedFallbackTool,
+                        readRawSpanTool: rcRawSpanTool,
+                        toolsetTools: rcToolset.toRuntimeTools(rcToolContext),
+                    }), reconcileTranscriptPath, 'reconcile', {
+                        onEntry: (entry) => {
+                            const summary = record(entry);
+                            if (!stage4) {
+                                return;
+                            }
+                            const label = `Reconciling results · ${summary.toolCallCount} action${summary.toolCallCount === 1 ? '' : 's'}`;
+                            emitStageProgress('reconciliation', 85, label, { transient: true });
+                            void stage4.updateProgress(Math.min(0.95, summary.toolCallCount / reconcileProgressSoftCap), label);
+                        },
+                    });
+                };
                 const reconcileStartedAt = Date.now();
                 const reconcileMode = contextReport && this.deps.curatorPagination ? 'curator' : 'single';
                 if (contextReport && this.deps.curatorPagination) {
@@ -1471,25 +1578,9 @@ export class IngestBundleRunner {
                             canonicalPins: relevantCanonicalPins,
                         }),
                         buildUserPrompt: ({ summary, items, runState }) => buildReconcileUserPrompt(stageIndex, eviction, { summary, items }, reconcileNotes, runState),
-                        buildToolSet: (_passNumber) => wrapToolsWithLogger(buildReconcileToolSet({
-                            loadSkillTool: rcLoadSkill,
-                            stageListTool: rcStageListTool,
-                            stageDiffTool: rcStageDiffTool,
-                            evictionListTool: rcEvictionListTool,
-                            emitConflictResolutionTool: rcEmitConflictResolutionTool,
-                            emitEvictionDecisionTool: rcEmitEvictionDecisionTool,
-                            emitArtifactResolutionTool: rcEmitArtifactResolutionTool,
-                            emitUnmappedFallbackTool: rcEmitUnmappedFallbackTool,
-                            readRawSpanTool: rcRawSpanTool,
-                            toolsetTools: rcToolset.toRuntimeTools(rcToolContext),
-                        }), join(transcriptDir, 'reconcile.jsonl'), 'reconcile', { onEntry: recordTranscriptEntry(join(transcriptDir, 'reconcile.jsonl')) }),
+                        buildToolSet: (_passNumber) => buildReconcileToolSetWithHeartbeat(),
                         getReconciliationActions: () => reconcileActions,
-                        onStepFinish: stage4
-                            ? ({ passNumber, stepIndex, stepBudget }) => {
-                                emitStageProgress('reconciliation', 85, `Reconciling results: pass ${passNumber} step ${stepIndex}/${stepBudget}`, { transient: true });
-                                void stage4.updateProgress(stepIndex / stepBudget, `Reconciling results · pass ${passNumber} step ${stepIndex}`);
-                            }
-                            : undefined,
+                        abortSignal: ctx?.abortSignal,
                     });
                     curatorReport = curatorOutcome.report;
                     curatorWarnings = curatorOutcome.warnings;
@@ -1512,31 +1603,13 @@ export class IngestBundleRunner {
                             canonicalPins: relevantCanonicalPins,
                         }),
                         buildUserPrompt: (idx, ev) => buildReconcileUserPrompt(idx, ev, undefined, reconcileNotes),
-                        buildToolSet: () => wrapToolsWithLogger(buildReconcileToolSet({
-                            loadSkillTool: rcLoadSkill,
-                            stageListTool: rcStageListTool,
-                            stageDiffTool: rcStageDiffTool,
-                            evictionListTool: rcEvictionListTool,
-                            emitConflictResolutionTool: rcEmitConflictResolutionTool,
-                            emitEvictionDecisionTool: rcEmitEvictionDecisionTool,
-                            emitArtifactResolutionTool: rcEmitArtifactResolutionTool,
-                            emitUnmappedFallbackTool: rcEmitUnmappedFallbackTool,
-                            readRawSpanTool: rcRawSpanTool,
-                            toolsetTools: rcToolset.toRuntimeTools(rcToolContext),
-                        }), join(transcriptDir, 'reconcile.jsonl'), 'reconcile', { onEntry: recordTranscriptEntry(join(transcriptDir, 'reconcile.jsonl')) }),
+                        buildToolSet: () => buildReconcileToolSetWithHeartbeat(),
                         modelRole: 'reconcile',
                         stepBudget: 60,
                         sourceKey: job.sourceKey,
                         jobId: job.jobId,
                         force: !!overrideReport,
-                        onStepFinish: stage4
-                            ? ({ stepIndex, stepBudget }) => {
-                                emitStageProgress('reconciliation', 85, `Reconciling results: step ${stepIndex}/${stepBudget}`, {
-                                    transient: true,
-                                });
-                                void stage4.updateProgress(stepIndex / stepBudget, `Reconciling results · step ${stepIndex}`);
-                            }
-                            : undefined,
+                        abortSignal: ctx?.abortSignal,
                     });
                 }
                 await runTrace.event('debug', 'reconciliation', 'reconciliation_executed', {
@@ -1890,6 +1963,7 @@ export class IngestBundleRunner {
                         repairKind: 'final_artifact_gate',
                         maxAttempts: 1,
                         stepBudget: 16,
+                        abortSignal: ctx?.abortSignal,
                     });
                     isolatedDiffSummary.gateRepairAttempts += gateRepair.attempts;
                     if (gateRepair.status === 'failed') {

package/dist/context/ingest/isolated-diff/textual-conflict-resolver.d.ts

@@ -19,5 +19,6 @@ export interface ResolveTextualConflictInput {
     reason: string;
     maxAttempts?: number;
     stepBudget?: number;
+    abortSignal?: AbortSignal;
 }
 export declare function resolveTextualConflict(input: ResolveTextualConflictInput): Promise<TextualConflictResolutionResult>;

package/dist/context/ingest/isolated-diff/textual-conflict-resolver.js

@@ -165,6 +165,7 @@ export async function resolveTextualConflict(input) {
                 jobId: input.trace.context.jobId,
                 unitKey: input.unitKey,
             },
+            abortSignal: input.abortSignal,
         }));
         if (result.stopReason === 'error') {
             lastFailure = result.error?.message ?? 'resolver agent loop errored';

package/dist/context/ingest/isolated-diff/work-unit-executor.d.ts

@@ -9,6 +9,7 @@ export interface RunIsolatedWorkUnitInput {
     patchDir: string;
     trace: IngestTraceWriter;
     workUnit: WorkUnit;
+    abortSignal?: AbortSignal;
     run(child: IngestSessionWorktree): Promise<WorkUnitOutcome>;
     afterSuccess?(child: IngestSessionWorktree): Promise<void>;
 }