@wrongstack/core 0.299.0 → 0.301.0

package/dist/design/index.js

@@ -66,6 +66,9 @@ function canonicalProjectRoot(absRoot) {
     const commonDirFile = path.join(gitDir, "commondir");
     if (!fs.statSync(commonDirFile).isFile()) return checkoutRoot;
     const commonDir = path.resolve(gitDir, fs.readFileSync(commonDirFile, "utf8").trim());
+    const worktreesDir = path.dirname(gitDir);
+    if (path.basename(worktreesDir).toLowerCase() !== "worktrees") return checkoutRoot;
+    if (path.resolve(worktreesDir, "..") !== commonDir) return checkoutRoot;
     if (path.basename(commonDir).toLowerCase() !== ".git") return checkoutRoot;
     return path.dirname(commonDir);
   } catch {
@@ -88,7 +91,7 @@ function safeProfileName(name) {
   const safe = (name ?? "").replace(/[/\\:]/g, "_").replace(/\.\./g, "_").trim();
   return safe || "default";
 }
-function activeProfileName(globalRoot) {
+function bootstrapProfileName(globalRoot) {
   try {
     const parsed = JSON.parse(fs.readFileSync(path.join(globalRoot, "config.json"), "utf8"));
     return safeProfileName(
@@ -106,7 +109,7 @@ function wstackGlobalRoot() {
 function resolveWstackPaths(opts) {
   const globalRoot = opts.globalRoot ?? (opts.userHome ? path.join(opts.userHome, ".wrongstack") : wstackGlobalRoot());
   const homeDir = opts.userHome ?? os.homedir();
-  const profileName = safeProfileName(opts.profileName ?? activeProfileName(globalRoot));
+  const profileName = safeProfileName(opts.profileName ?? bootstrapProfileName(globalRoot));
   const profileDir = path.join(globalRoot, "profiles", profileName);
   const hash = projectHash(opts.projectRoot);
   const slug = projectSlug(opts.projectRoot);
@@ -176,7 +179,12 @@ function resolveWstackPaths(opts) {
     projectRequirementIntakes: path.join(projectDir, "requirement-intakes"),
     syncConfig: path.join(profileDir, "sync.json"),
     configHistoryDir: path.join(globalRoot, "config-history"),
-    projectStatus: (projectHash2) => path.join(globalRoot, "projects", projectHash2, "status.json")
+    projectStatus: (statusProjectSlug) => {
+      if (!/^[a-z0-9](?:[a-z0-9-]{0,39})-[a-f0-9]{6}$/.test(statusProjectSlug)) {
+        throw new Error(`Invalid project slug: ${statusProjectSlug}`);
+      }
+      return path.join(globalRoot, "projects", statusProjectSlug, "status.json");
+    }
   };
 }
 

package/dist/execution/auto-compaction-middleware.d.ts

@@ -138,6 +138,8 @@ export declare class AutoCompactionMiddleware {
      * the caller falls back to a fresh walk.
      */
     private tryStashedTokens;
+    /** Invalidate every token view derived from the pre-rewrite conversation. */
+    private invalidateTokenCaches;
     /**
      * Returns true when the previous compaction at the same or higher pressure
      * level reduced nothing and context has not grown materially since. Prevents
@@ -158,6 +160,21 @@ export declare class AutoCompactionMiddleware {
     private emergencyTrim;
     /** Preserve-window size from the active policy, defaulting to 6 recent pairs. */
     private resolvePreserveK;
+    /**
+     * Aggregate raw acknowledged tool-I/O budget from the active mode.
+     *
+     * `eliseThreshold` remains the per-result baseline. Multiplying it by the
+     * preserve window gives recent multi-tool investigations breathing room;
+     * the 12% context cap prevents deep mode or huge custom thresholds from
+     * turning that room into another unbounded prompt owner.
+     */
+    private resolveToolResultRetention;
+    /**
+     * Number of recent completed tool exchanges kept as semantic receipts.
+     * Four receipts per preserve slot retains a useful investigation trail; the
+     * absolute bounds keep frugal mode useful and deep mode finite.
+     */
+    private resolveToolReceiptRetention;
 }
 export {};
 //# sourceMappingURL=auto-compaction-middleware.d.ts.map

package/dist/execution/autonomy-brain.d.ts

@@ -26,11 +26,11 @@
  *     onDecision: (summary) => journal.push(summary),
  *   });
  */
-import type { Provider, Usage } from '../types/provider.js';
 import { type BrainArbiter, type BrainDecision, type BrainDecisionRequest } from '../coordination/brain.js';
 import { type BrainHeuristicsConfig } from '../coordination/brain-heuristics.js';
-import type { BrainCircuitBreaker } from './brain-circuit.js';
 import type { EventBus } from '../kernel/events.js';
+import type { Provider, ResponseFormat, Usage } from '../types/provider.js';
+import type { BrainCircuitBreaker } from './brain-circuit.js';
 /** One (provider, model) pair the Brain may call for a decision. */
 export interface BrainLlmTarget {
     provider: Provider;
@@ -218,6 +218,8 @@ export declare function completeBrainLlm(target: BrainLlmTarget, input: {
     user: string;
     timeoutMs: number;
     maxTokens?: number | undefined;
+    /** External cancellation (e.g. a council's overall budget or user abort). */
+    signal?: AbortSignal | undefined;
 }): Promise<string>;
 /** Text plus the observable call metadata a trace/quality gate needs. */
 interface BrainLlmCallResult {
@@ -237,12 +239,23 @@ interface BrainLlmCallResult {
  * Usage was previously thrown away at this boundary, which is why the council
  * adapter reported hardcoded zero tokens for every seat and why "what do
  * Brain decisions cost" had no answer.
+ *
+ * The per-call timeout is composed with any caller-supplied `signal` so an
+ * external abort (the council's overall budget, a user cancel) interrupts an
+ * in-flight provider call instead of waiting out the per-call timeout.
  */
 export declare function completeBrainLlmDetailed(target: BrainLlmTarget, input: {
     system: string;
     user: string;
     timeoutMs: number;
     maxTokens?: number | undefined;
+    /**
+     * Wire-level response format (e.g. json_object). Callers that parse the
+     * response as JSON (the council seats) must pass this through — prompt
+     * wording alone does not put a provider into JSON mode.
+     */
+    responseFormat?: ResponseFormat | undefined;
+    signal?: AbortSignal | undefined;
 }): Promise<BrainLlmCallResult>;
 /**
  * Output budget for a Brain decision call.

package/dist/execution/brain-runtime.d.ts

@@ -25,8 +25,8 @@
  */
 import { type BrainArbiter, type BrainDecisionRequest, type BrainEscalationMode, type BrainTerminalPolicy } from '../coordination/brain.js';
 import type { BrainHeuristicsConfig } from '../coordination/brain-heuristics.js';
-import type { EventBus } from '../kernel/events.js';
 import { type BrainRule } from '../coordination/brain-rules.js';
+import type { EventBus } from '../kernel/events.js';
 import type { BrainConfig, BrainCouncilVoterConfig, BrainModelEntry } from '../types/config.js';
 import type { Provider } from '../types/provider.js';
 import { type BrainAutoRisk } from './autonomy-brain.js';
@@ -55,6 +55,7 @@ export interface BrainConfigSnapshot {
         perCallTimeoutMs: number | undefined;
         maxConcurrency: number | undefined;
         distinctness: 'none' | 'model' | 'provider';
+        voterMaxTokens: number | undefined;
         judgeMaxTokens: number | undefined;
         seats: Array<{
             persona: string;
@@ -152,6 +153,7 @@ export interface BrainCouncilPatch {
     perCallTimeoutMs?: number | null | undefined;
     maxConcurrency?: number | null | undefined;
     distinctness?: 'none' | 'model' | 'provider' | null | undefined;
+    voterMaxTokens?: number | null | undefined;
     judgeMaxTokens?: number | null | undefined;
     seats?: Array<{
         persona: string;

package/dist/execution/compaction-core.d.ts

@@ -1,7 +1,7 @@
-import type { Message } from '../types/messages.js';
 import type { Logger } from '../types/logger.js';
+import type { Message } from '../types/messages.js';
 import { estimateMessageTokens } from '../utils/token-estimate.js';
-export { buildSmartDigest, extractText, hasLargeToolResult, hasToolUse, scoreMessage, type ContentScore, } from './compaction-scoring.js';
+export { buildSmartDigest, type ContentScore, extractText, hasLargeToolResult, hasToolUse, scoreMessage, } from './compaction-scoring.js';
 /** Set the module-level compaction debug logger (called by compactor constructors). */
 export declare function setCompactionDebugLogger(logger: Logger | undefined): void;
 /**
@@ -42,6 +42,45 @@ export interface EliseResult {
     saved: number;
     changed: boolean;
 }
+export interface AcknowledgedToolResultElision extends EliseResult {
+    /** Raw tool-result blocks replaced with compact receipts. */
+    elidedResults: number;
+    /** Raw acknowledged tool I/O left verbatim after the pass. */
+    retainedTokens: number;
+}
+export interface AcknowledgedToolReceiptCollapse extends EliseResult {
+    /** Complete acknowledged tool exchanges folded into the bounded digest. */
+    collapsedPairs: number;
+}
+/**
+ * Bound raw tool I/O that the model has already consumed successfully.
+ *
+ * A result is acknowledged only when a later assistant message exists. The
+ * trailing tool-result batch therefore stays verbatim until it has actually
+ * reached the provider; retries and recovered sessions cannot lose the input
+ * needed for their next request. Among acknowledged pairs, the newest raw
+ * payloads share `maxRetainedTokens`; older or individually oversized pairs
+ * become semantic receipts while their exact payload remains in the session
+ * log. Tool ids and provider metadata stay intact so strict provider replay
+ * adjacency remains valid.
+ */
+export declare function eliseAcknowledgedToolResults(messages: readonly Message[], opts: {
+    maxRetainedTokens: number;
+}): AcknowledgedToolResultElision;
+/**
+ * Bound the number of acknowledged tool-protocol pairs retained in history.
+ *
+ * Raw payload elision bounds bytes, but every receipt still leaves an
+ * assistant tool_use message and a user tool_result message behind. Long
+ * autonomous sessions therefore continued to grow linearly in protocol
+ * shells. This pass keeps the newest `maxPairs`, removes both halves of older
+ * pairs, drops thinking that existed solely to authorize an omitted tool call,
+ * and folds the count into one stable system digest. Surrounding assistant or
+ * user text is preserved.
+ */
+export declare function collapseAcknowledgedToolReceipts(messages: readonly Message[], opts: {
+    maxPairs: number;
+}): AcknowledgedToolReceiptCollapse;
 /**
  * Elide oversized tool I/O that falls before the preserve window. Pure:
  * returns a fresh array (or the same reference when unchanged). Replaces the

package/dist/execution/council-brain.d.ts

@@ -20,7 +20,9 @@
  */
 import type { BrainArbiter, BrainDecisionRequest } from '../coordination/brain.js';
 import type { EventBus } from '../kernel/events.js';
+import type { CouncilLLMCaller } from '../types/council.js';
 import type { Provider } from '../types/provider.js';
+import { type BrainLlmTarget } from './autonomy-brain.js';
 /**
  * Refusal option id used by the Brain adapter. Re-exported from the
  * orchestrator so both layers share a single source of truth.
@@ -53,12 +55,25 @@ export interface CouncilBrainOptions {
     quorumFraction?: number | undefined;
     /** Winning option weight must exceed this fraction. Default 0.5. */
     approvalFraction?: number | undefined;
-    /** Per-voter completion timeout in ms. Default 15 000. */
+    /**
+     * Per-voter completion timeout in ms. Default
+     * {@link BRAIN_COUNCIL_DEFAULT_PER_CALL_TIMEOUT_MS} (45s) — a council
+     * convenes for high-stakes decisions only, and reasoning models routinely
+     * take longer than the single-LLM tier's 15s before their first token.
+     */
     decisionTimeoutMs?: number | undefined;
     /** Seats polled concurrently, 1..8. Default 3 (the orchestrator's default). */
     maxConcurrency?: number | undefined;
     /** Panel-diversity warning policy. Default 'none'. */
     distinctness?: 'none' | 'model' | 'provider' | undefined;
+    /**
+     * Output budget per voter seat call. Default
+     * {@link BRAIN_COUNCIL_DEFAULT_VOTER_MAX_TOKENS}. Reasoning models spend
+     * their thinking tokens from this same budget, so the orchestrator's
+     * generic 300-token default starves them into `invalid` votes (empty or
+     * truncated JSON).
+     */
+    voterMaxTokens?: number | undefined;
     /** Output budget for the judge call. */
     judgeMaxTokens?: number | undefined;
     /** Optional digest of past decisions for context. */
@@ -75,6 +90,37 @@ export interface CouncilBrainOptions {
      */
     traceContent?: boolean | undefined;
 }
+/**
+ * Default output budget per Brain-council voter seat.
+ *
+ * Deliberately larger than the orchestrator's generic 300-token default
+ * (`DEFAULT_COUNCIL_VOTER_MAX_TOKENS`): a vote is still just one optionId
+ * plus a short rationale, but reasoning models (deepseek-v4, glm, kimi, …)
+ * burn their chain-of-thought from the same `maxTokens` budget before any
+ * visible text appears. 300 reliably produced empty/truncated responses →
+ * `invalid` votes; 2000 leaves room to think and answer. Override via
+ * `brain.council.voterMaxTokens`.
+ */
+export declare const BRAIN_COUNCIL_DEFAULT_VOTER_MAX_TOKENS = 2000;
+/**
+ * Default per-seat completion timeout for the Brain council.
+ *
+ * Deliberately larger than the single-LLM tier's 15s: the council only
+ * convenes for high-stakes questions, and reasoning models on the panel
+ * often need more than 15s before their first visible token — at 15s they
+ * surfaced as `failed` seats on every convene. Override via
+ * `brain.council.perCallTimeoutMs` (or `brain.decisionTimeoutMs`).
+ */
+export declare const BRAIN_COUNCIL_DEFAULT_PER_CALL_TIMEOUT_MS = 45000;
+/**
+ * Build the per-seat LLM caller that wraps `completeBrainLlmDetailed` for
+ * one BrainLlmTarget. Exported so tests can drive the exact production
+ * wiring: it forwards the orchestrator's `input.signal` (overall budget +
+ * caller cancellation) into the provider call so an in-flight seat is
+ * interrupted on timeout/cancel instead of running out its per-call
+ * timeout.
+ */
+export declare function makeSeatCallerForVoter(target: BrainLlmTarget): CouncilLLMCaller;
 /**
  * Create a council-of-LLMs Brain arbiter backed by CouncilOrchestrator
  * with per-seat LLM callers — each voter's own Provider is used for its

package/dist/execution/council-orchestrator.d.ts

@@ -1,8 +1,8 @@
+import type { FallbackProfileManager } from '../core/fallback-profile-manager.js';
+import type { Config } from '../types/config.js';
 import type { CouncilLLMCaller, CouncilQuestion, CouncilResult } from '../types/council.js';
 import { type CouncilPersonaRegistry } from './council-personas.js';
 import { type CouncilProfileRegistry } from './council-profiles.js';
-import type { FallbackProfileManager } from '../core/fallback-profile-manager.js';
-import type { Config } from '../types/config.js';
 /** Synthetic ballot entry for "refuse every real option". */
 export declare const COUNCIL_REFUSAL_OPTION_ID = "council_refuse";
 export declare const DEFAULT_COUNCIL_MAX_CONCURRENCY = 3;
@@ -53,17 +53,36 @@ export declare class CouncilOrchestrator {
     private readonly fallbackProfileManager;
     private readonly seatCaller;
     private readonly judgeCaller;
+    /**
+     * Normalized ad-hoc profiles keyed by the caller's config object identity.
+     * The Brain adapter reuses ONE profile object for every decision, so this
+     * avoids re-validating + re-freezing it on every ask() without caching
+     * string-keyed registry lookups (those are already O(1)).
+     *
+     * Hosts must treat ad-hoc profile configs as IMMUTABLE once passed to
+     * ask(): the cache is keyed by object identity and never invalidated, so
+     * mutating a cached profile would silently serve the first snapshot.
+     */
+    private readonly profileCache;
     constructor(opts: CouncilOrchestratorOptions);
+    /**
+     * Resolve the effective profile for a question. String ids and the default
+     * go through the registry (already O(1)); ad-hoc config objects are
+     * normalized once per stable object identity and cached, because hosts such
+     * as the Brain adapter pass the same profile object on every ask().
+     */
+    private resolveProfile;
     ask(question: CouncilQuestion): Promise<CouncilResult>;
     private callSeat;
     private resolveOptionQuestion;
     private resolveOpenQuestion;
     private callJudge;
     /**
-     * Resolve the effective LLM caller for a call. Voter seats use
-     * `seatCaller(seatIndex)` when wired. Judge seats (seatIndex undefined)
-     * use `judgeCaller` if set, otherwise `seatCaller(0)` if set, otherwise
-     * the shared `caller`.
+     * Resolve the effective LLM caller for a call. Voter seats (defined
+     * seatIndex) use `seatCaller(seatIndex)` when wired, otherwise the shared
+     * `caller` — a seat never falls through to the judge caller. Judge seats
+     * (seatIndex undefined) use `judgeCaller` if set, otherwise `seatCaller(0)`
+     * if set, otherwise the shared `caller`.
      */
     private resolveCaller;
     private safeCall;

package/dist/execution/council-prompts.d.ts

@@ -1,4 +1,4 @@
-import type { CouncilPersona, CouncilQuestion, CouncilVoteResult, ResolvedCouncilSeat } from '../types/council.js';
+import type { CouncilOption, CouncilPersona, CouncilQuestion, CouncilVoteResult, ResolvedCouncilSeat } from '../types/council.js';
 export declare const COUNCIL_VOTER_PROMPT_PATH = "llm/council-voter.md";
 export declare const COUNCIL_JUDGE_PROMPT_PATH = "llm/council-judge.md";
 /** Build the trusted system instruction for one independent seat. */
@@ -18,4 +18,15 @@ export declare function buildCouncilJudgeUserPrompt(question: CouncilQuestion, v
     reason?: string | undefined;
     refusalOptionId?: string | undefined;
 }): string;
+/**
+ * Validate a Council option list; returns human-readable problems (empty
+ * array = valid). Single source of the id/label/duplicate rules shared by the
+ * `council` tool validator (fixable errors returned to the caller) and the
+ * prompt builder (which throws with every problem joined).
+ *
+ * Note: empty ids are added to the `seen` set, so two empty-id options also
+ * report `Duplicate option id ""` next to the empty-id error — harmless noise
+ * that preserves the historical tool-validator behavior exactly.
+ */
+export declare function validateCouncilOptions(options: readonly CouncilOption[] | undefined): string[];
 //# sourceMappingURL=council-prompts.d.ts.map

package/dist/execution/index.d.ts

@@ -1,34 +1,35 @@
 export { AutoCompactionMiddleware, type ContextWindowBudgetSnapshot, } from './auto-compaction-middleware.js';
-export { installSubagentAutoCompaction } from './subagent-compaction.js';
 export { AutonomousRunner, type AutonomousRunnerOptions, type DoneCheckResult, DoneConditionChecker, } from './autonomous-runner.js';
 export { type AutonomyBrainOptions, type BrainAutoRisk, type BrainLlmTarget, buildBrainUserMessage, completeBrainLlm, createAutonomyBrain, createTieredBrainArbiter, formatDecisionSummary, parseOptionDecision, type TieredBrainArbiterOptions, } from './autonomy-brain.js';
+export { type AutonomyPromptContributorOptions, makeAutonomyPromptContributor, } from './autonomy-prompt-contributor.js';
 export { assembleBrainTiers, type BrainTierAssembly, type BrainTierAssemblyOptions, } from './brain-chain.js';
 export { BRAIN_EVALUATION_CASE_VERSION, type BrainEvaluationCaseResult, type BrainEvaluationCaseV1, type BrainEvaluationCaseValidation, type BrainEvaluationExpectations, type BrainEvaluationFailure, type BrainEvaluationFailureCode, type BrainEvaluationMetrics, type BrainEvaluationReport, runBrainEvaluation, validateBrainEvaluationCase, } from './brain-evaluation.js';
 export { type BrainApplyResult, type BrainConfigPatch, type BrainConfigSnapshot, type BrainCouncilMinRisk, type BrainCouncilPatch, type BrainDefaultsContext, type BrainPoolStrategy, type BrainRuntime, type BrainRuntimeLedgerHost, type BrainRuntimeOptions, createBrainRuntime, resolveBrainConfigDefaults, } from './brain-runtime.js';
+export { type CompactorOptions, HybridCompactor } from './compactor.js';
 export { COUNCIL_REFUSE_OPTION_ID, type CouncilBrainOptions, type CouncilVoter, createCouncilBrainArbiter, } from './council-brain.js';
-export { type CouncilResolution, type CouncilResolutionInput, type CouncilResolutionSeat, type CouncilResolutionVote, resolveCouncilVotes, } from './council-resolution.js';
+export { COUNCIL_REFUSAL_OPTION_ID, CouncilOrchestrator, type CouncilOrchestratorOptions, DEFAULT_COUNCIL_MAX_CONCURRENCY, MAX_COUNCIL_CONCURRENCY, } from './council-orchestrator.js';
 export { BUILTIN_COUNCIL_PERSONA_IDS, BUILTIN_COUNCIL_PERSONAS, CouncilPersonaRegistry, createCouncilPersonaRegistry, DEFAULT_COUNCIL_PERSONA_REGISTRY, } from './council-personas.js';
 export { BUILTIN_COUNCIL_PROFILES, CouncilProfileRegistry, createCouncilProfileRegistry, DEFAULT_COUNCIL_APPROVAL_FRACTION, DEFAULT_COUNCIL_JUDGE_MAX_TOKENS, DEFAULT_COUNCIL_OVERALL_TIMEOUT_MS, DEFAULT_COUNCIL_PER_CALL_TIMEOUT_MS, DEFAULT_COUNCIL_PROFILE_REGISTRY, DEFAULT_COUNCIL_QUORUM_FRACTION, DEFAULT_COUNCIL_VOTER_MAX_TOKENS, normalizeCouncilProfile, resolveCouncilProfile, } from './council-profiles.js';
 export { buildCouncilJudgeSystemPrompt, buildCouncilJudgeUserPrompt, buildCouncilQuestionPrompt, buildCouncilVoterSystemPrompt, buildCouncilVoterUserPrompt, COUNCIL_JUDGE_PROMPT_PATH, COUNCIL_VOTER_PROMPT_PATH, } from './council-prompts.js';
-export { COUNCIL_REFUSAL_OPTION_ID, CouncilOrchestrator, type CouncilOrchestratorOptions, DEFAULT_COUNCIL_MAX_CONCURRENCY, MAX_COUNCIL_CONCURRENCY, } from './council-orchestrator.js';
-export { type AutonomyPromptContributorOptions, makeAutonomyPromptContributor, } from './autonomy-prompt-contributor.js';
-export { type CompactorOptions, HybridCompactor } from './compactor.js';
+export { type CouncilResolution, type CouncilResolutionInput, type CouncilResolutionSeat, type CouncilResolutionVote, resolveCouncilVotes, } from './council-resolution.js';
 export { activateDesign, clearActiveKit, detectFrontendFile, detectFrontendIntent, getDesignState, installDesignStudioMiddleware, makeDesignDetectToolCallMiddleware, makeDesignDetectUserInputMiddleware, makeDesignStudioRequestMiddleware, setActiveKit, } from './design-detect.js';
 export { _resetDesignKitLoaderMemo, DefaultDesignKitLoader, type DesignKitLoaderOptions, getDesignKitLoader, resolveBundledDesignKitsDir, } from './design-kit-loader.js';
 export { _resetDesignRulesCache, clearPersistedActiveKit, designProjectDir, loadActiveKit, loadProjectDesignRules, type PersistedActiveKit, recordKitChoice, } from './design-project-store.js';
+export { nextEnhanceTimeout, resolveConfiguredRefinerRef, resolveEnhanceFallbackRef, } from './enhance-recovery.js';
 export { buildRecoveryStrategies, DEFAULT_RECOVERY_STRATEGIES, DefaultErrorHandler, type RecoveryStrategy, } from './error-handler.js';
 export { EternalAutonomyEngine, type EternalAutonomyOptions, type EternalEngineState, type IterationStage, } from './eternal-autonomy.js';
 export { buildGoalPreamble } from './goal-preamble.js';
 export { IntelligentCompactor, type IntelligentCompactorOptions } from './intelligent-compactor.js';
-export { applyModelRuntime, mergeModelRuntime, type ModelRuntimeMiddlewareOptions, type ResolvedModelRuntime, resolveCacheForRequest, resolveModelRuntime, resolveReasoningForRequest, } from './model-runtime.js';
+export { applyModelRuntime, type ModelRuntimeMiddlewareOptions, mergeModelRuntime, type ResolvedModelRuntime, resolveCacheForRequest, resolveModelRuntime, resolveReasoningForRequest, } from './model-runtime.js';
+export { OneShotOrchestrator } from './one-shot-llm.js';
 export { type ParallelEngineState, ParallelEternalEngine, type ParallelEternalOptions, type ParallelIterationStage, } from './parallel-eternal-engine.js';
+export { buildRefinerContextSections, DEFAULT_REFINER_RETRY_FEEDBACK, type EnhanceFailureKind, enhanceUserPrompt, gatedEnhancerReasoning, isValidEnglishRefinement, normalizedEqual, parseBilingualEnhancement, recentTextTurns, shouldEnhance, } from './prompt-enhancer.js';
+export { DefaultPromptLoader, type PromptLoaderOptions, renderPrompt } from './prompt-loader.js';
 export { DefaultRetryPolicy } from './retry-policy.js';
 export { SelectiveCompactor, type SelectiveCompactorOptions } from './selective-compactor.js';
 export { DefaultSkillLoader, type SkillLoaderOptions } from './skill-loader.js';
-export { DefaultPromptLoader, type PromptLoaderOptions, renderPrompt } from './prompt-loader.js';
 export { type CompactorStrategy, createStrategyCompactor, type StrategyCompactorOptions, } from './strategy-compactor.js';
+export { installSubagentAutoCompaction } from './subagent-compaction.js';
 export { ToolExecutor } from './tool-executor.js';
-export { OneShotOrchestrator } from './one-shot-llm.js';
-export { buildRefinerContextSections, DEFAULT_REFINER_RETRY_FEEDBACK, enhanceUserPrompt, gatedEnhancerReasoning, type EnhanceFailureKind, isValidEnglishRefinement, normalizedEqual, parseBilingualEnhancement, recentTextTurns, shouldEnhance, } from './prompt-enhancer.js';
-export { nextEnhanceTimeout, resolveConfiguredRefinerRef, resolveEnhanceFallbackRef, } from './enhance-recovery.js';
+export { startFreshTopicContext, type TopicShiftAdvice, TopicShiftAdvisor, type TopicShiftAdvisorInput, type TopicShiftAdvisorOptions, } from './topic-shift-advisor.js';
 //# sourceMappingURL=index.d.ts.map