@cleocode/cant 2026.4.11 → 2026.4.13

package/dist/composer.d.ts

@@ -0,0 +1,165 @@
+/**
+ * JIT Agent Composer -- composes agent spawn payloads at runtime.
+ *
+ * Takes a compiled agent definition + context sources + mental model
+ * and produces a token-budgeted system prompt with tier escalation.
+ *
+ * Implements ULTRAPLAN section 9.3: at spawn time, the composer resolves context
+ * sources from BRAIN, loads the agent's mental model, enforces token budgets
+ * per tier, and escalates tiers when content overflows.
+ *
+ * @packageDocumentation
+ */
+/** Token budget caps per tier. */
+export declare const TIER_CAPS: {
+    readonly low: {
+        readonly systemPrompt: 4000;
+        readonly mentalModel: 0;
+        readonly contextSources: 0;
+    };
+    readonly mid: {
+        readonly systemPrompt: 12000;
+        readonly mentalModel: 1000;
+        readonly contextSources: 4000;
+    };
+    readonly high: {
+        readonly systemPrompt: 32000;
+        readonly mentalModel: 2000;
+        readonly contextSources: 12000;
+    };
+};
+/** Agent tier levels: low, mid, or high. */
+export type Tier = 'low' | 'mid' | 'high';
+/**
+ * Return the next tier up for escalation.
+ *
+ * @param tier - The current tier.
+ * @returns The next tier, or `null` if already at the highest tier.
+ */
+export declare function escalateTier(tier: Tier): Tier | null;
+/**
+ * Rough token estimation: approximately 4 characters per token.
+ *
+ * @param text - The text to estimate tokens for.
+ * @returns The estimated token count.
+ */
+export declare function estimateTokens(text: string): number;
+/** A context source query result from BRAIN. */
+export interface ContextSlice {
+    /** The source category (e.g. "patterns", "decisions", "conventions"). */
+    source: string;
+    /** The retrieved text content. */
+    content: string;
+    /** Pre-computed token count for this slice. */
+    tokens: number;
+}
+/** A mental model loaded from BRAIN. */
+export interface MentalModelSlice {
+    /** The mental model text content. */
+    content: string;
+    /** Pre-computed token count for this slice. */
+    tokens: number;
+    /** ISO date of the last consolidation, or `null` if never consolidated. */
+    lastConsolidated: string | null;
+}
+/**
+ * Interface for BRAIN context retrieval (mockable for testing).
+ *
+ * @remarks
+ * Implementations should query the BRAIN database for relevant context
+ * and mental model data, respecting the provided token budgets.
+ */
+export interface ContextProvider {
+    /** Retrieve context for a named source with a token budget. */
+    queryContext(source: string, query: string, maxTokens: number): Promise<ContextSlice>;
+    /** Load the mental model for an agent + project. */
+    loadMentalModel(agentName: string, projectHash: string, maxTokens: number): Promise<MentalModelSlice>;
+}
+/** The composed spawn payload returned by {@link composeSpawnPayload}. */
+export interface SpawnPayload {
+    /** The agent name. */
+    agentName: string;
+    /** The resolved tier (may be escalated from declared tier). */
+    resolvedTier: Tier;
+    /** Whether the tier was escalated from the declared tier. */
+    escalated: boolean;
+    /** The original declared tier. */
+    declaredTier: Tier;
+    /** The composed system prompt. */
+    systemPrompt: string;
+    /** Token count of the system prompt. */
+    systemPromptTokens: number;
+    /** The model to use (from the tier matrix). */
+    model: string;
+    /** Fallback models. */
+    fallbackModels: string[];
+    /** Skills to load. */
+    skills: string[];
+    /** Tools allowed. */
+    tools: string[];
+    /** Context sources that were injected. */
+    injectedContextSources: string[];
+    /** Whether mental model was injected. */
+    mentalModelInjected: boolean;
+}
+/** Agent definition extracted from a compiled `.cant` bundle. */
+export interface AgentDefinition {
+    /** The agent name as declared in the `.cant` file. */
+    name: string;
+    /** The declared tier for this agent. */
+    tier: Tier;
+    /** The base system prompt for this agent. */
+    prompt: string;
+    /** Skills this agent should load. */
+    skills: string[];
+    /** Tools this agent is allowed to use. */
+    tools: string[];
+    /** Context sources to resolve from BRAIN at spawn time. */
+    contextSources: Array<{
+        /** The BRAIN source category. */
+        source: string;
+        /** The query string for context retrieval. */
+        query: string;
+        /** Maximum number of entries to retrieve. */
+        maxEntries: number;
+    }>;
+    /**
+     * Mental model configuration, or `null` if not enabled.
+     *
+     * @remarks
+     * When enabled, the composer loads the agent's mental model from BRAIN
+     * and injects it with a validation prefix instructing the agent to
+     * re-evaluate each claim against the current code state.
+     */
+    mentalModel: {
+        /** Whether the mental model is enabled. */
+        enabled: boolean;
+        /** Scope: project-specific or global. */
+        scope: 'project' | 'global';
+        /** Maximum tokens allocated for mental model content. */
+        maxTokens: number;
+        /** Whether to add a validation prefix before the mental model. */
+        validateOnLoad: boolean;
+    } | null;
+    /** Behavior when total tokens exceed the tier cap. */
+    onOverflow: 'escalate_tier' | 'fail';
+}
+/**
+ * Compose a spawn payload for an agent.
+ *
+ * Implements ULTRAPLAN section 9.3 spawn-time composition:
+ * 1. Start with agent's declared tier
+ * 2. Resolve `context_sources` via {@link ContextProvider}
+ * 3. Load `mental_model` via {@link ContextProvider}
+ * 4. Check token budget -- if over, escalate tier (per L4)
+ * 5. Compose final system prompt
+ *
+ * @param agent - The agent definition from a compiled `.cant` bundle.
+ * @param contextProvider - The BRAIN context retrieval interface.
+ * @param projectHash - Hash identifying the current project for scoped queries.
+ * @returns The composed spawn payload ready for PiHarness.spawnSubagent.
+ *
+ * @throws Error if context exceeds the `high` tier cap and `onOverflow` is `'fail'`
+ * @throws Error if context exceeds the `high` tier cap even with escalation
+ */
+export declare function composeSpawnPayload(agent: AgentDefinition, contextProvider: ContextProvider, projectHash: string): Promise<SpawnPayload>;

package/dist/composer.js

@@ -0,0 +1,160 @@
+"use strict";
+/**
+ * JIT Agent Composer -- composes agent spawn payloads at runtime.
+ *
+ * Takes a compiled agent definition + context sources + mental model
+ * and produces a token-budgeted system prompt with tier escalation.
+ *
+ * Implements ULTRAPLAN section 9.3: at spawn time, the composer resolves context
+ * sources from BRAIN, loads the agent's mental model, enforces token budgets
+ * per tier, and escalates tiers when content overflows.
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TIER_CAPS = void 0;
+exports.escalateTier = escalateTier;
+exports.estimateTokens = estimateTokens;
+exports.composeSpawnPayload = composeSpawnPayload;
+// ---------------------------------------------------------------------------
+// Token budget caps per tier (ULTRAPLAN section 9.4)
+// ---------------------------------------------------------------------------
+/** Token budget caps per tier. */
+exports.TIER_CAPS = {
+    low: { systemPrompt: 4000, mentalModel: 0, contextSources: 0 },
+    mid: { systemPrompt: 12000, mentalModel: 1000, contextSources: 4000 },
+    high: { systemPrompt: 32000, mentalModel: 2000, contextSources: 12000 },
+};
+/**
+ * Return the next tier up for escalation.
+ *
+ * @param tier - The current tier.
+ * @returns The next tier, or `null` if already at the highest tier.
+ */
+function escalateTier(tier) {
+    if (tier === 'low')
+        return 'mid';
+    if (tier === 'mid')
+        return 'high';
+    return null;
+}
+/**
+ * Rough token estimation: approximately 4 characters per token.
+ *
+ * @param text - The text to estimate tokens for.
+ * @returns The estimated token count.
+ */
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+// ---------------------------------------------------------------------------
+// Model selection per tier (mirrors cant-router section 11)
+// ---------------------------------------------------------------------------
+/** Model selection per tier. */
+const TIER_MODELS = {
+    low: { primary: 'claude-haiku-4-5', fallbacks: ['kimi-k2.5'] },
+    mid: { primary: 'claude-sonnet-4-6', fallbacks: ['kimi-k2.5', 'claude-haiku-4-5'] },
+    high: { primary: 'claude-opus-4-6', fallbacks: ['claude-sonnet-4-6', 'kimi-k2.5'] },
+};
+// ---------------------------------------------------------------------------
+// Mental model validation prefix (ULTRAPLAN section 12.3)
+// ---------------------------------------------------------------------------
+/** Validation prefix injected before mental model content. */
+const MENTAL_MODEL_VALIDATION_PREFIX = 'VALIDATE THIS MENTAL MODEL. Re-evaluate each claim against current ' +
+    'code state. Mental models are dynamic per project; assume drift.';
+// ---------------------------------------------------------------------------
+// Core composer
+// ---------------------------------------------------------------------------
+/**
+ * Compose a spawn payload for an agent.
+ *
+ * Implements ULTRAPLAN section 9.3 spawn-time composition:
+ * 1. Start with agent's declared tier
+ * 2. Resolve `context_sources` via {@link ContextProvider}
+ * 3. Load `mental_model` via {@link ContextProvider}
+ * 4. Check token budget -- if over, escalate tier (per L4)
+ * 5. Compose final system prompt
+ *
+ * @param agent - The agent definition from a compiled `.cant` bundle.
+ * @param contextProvider - The BRAIN context retrieval interface.
+ * @param projectHash - Hash identifying the current project for scoped queries.
+ * @returns The composed spawn payload ready for PiHarness.spawnSubagent.
+ *
+ * @throws Error if context exceeds the `high` tier cap and `onOverflow` is `'fail'`
+ * @throws Error if context exceeds the `high` tier cap even with escalation
+ */
+async function composeSpawnPayload(agent, contextProvider, projectHash) {
+    let currentTier = agent.tier;
+    let escalated = false;
+    // Step 1: Build base prompt
+    const basePrompt = agent.prompt;
+    const baseTokens = estimateTokens(basePrompt);
+    // Step 2: Resolve context sources within the current tier's budget
+    const contextSlices = [];
+    let contextBudget = exports.TIER_CAPS[currentTier].contextSources;
+    for (const src of agent.contextSources) {
+        if (contextBudget <= 0)
+            break;
+        const slice = await contextProvider.queryContext(src.source, src.query, contextBudget);
+        contextSlices.push(slice);
+        contextBudget -= slice.tokens;
+    }
+    // Step 3: Load mental model if enabled and tier allows it
+    let mentalModel = null;
+    if (agent.mentalModel?.enabled) {
+        const mmCap = exports.TIER_CAPS[currentTier].mentalModel;
+        if (mmCap > 0) {
+            mentalModel = await contextProvider.loadMentalModel(agent.name, agent.mentalModel.scope === 'project' ? projectHash : 'global', mmCap);
+        }
+    }
+    // Step 4: Check total token budget and escalate if needed
+    const contextText = contextSlices.map((s) => s.content).join('\n\n');
+    const mmText = mentalModel?.content ?? '';
+    const totalTokens = baseTokens + estimateTokens(contextText) + estimateTokens(mmText);
+    // Escalation loop: keep escalating until the content fits or we hit the ceiling
+    let effectiveTier = currentTier;
+    while (totalTokens > exports.TIER_CAPS[effectiveTier].systemPrompt) {
+        if (agent.onOverflow === 'fail') {
+            throw new Error(`Agent ${agent.name}: total tokens (${totalTokens}) exceeds ` +
+                `${effectiveTier} tier cap (${exports.TIER_CAPS[effectiveTier].systemPrompt}) ` +
+                `and onOverflow is 'fail'`);
+        }
+        const next = escalateTier(effectiveTier);
+        if (next === null) {
+            throw new Error(`Agent ${agent.name}: total tokens (${totalTokens}) exceeds ` +
+                `high tier cap (${exports.TIER_CAPS.high.systemPrompt}) — cannot escalate further`);
+        }
+        effectiveTier = next;
+        escalated = true;
+    }
+    currentTier = effectiveTier;
+    // Step 5: Compose system prompt
+    const parts = [basePrompt];
+    if (contextSlices.length > 0) {
+        parts.push('\n\n## Context (JIT-injected)\n');
+        for (const slice of contextSlices) {
+            parts.push(`### ${slice.source}\n${slice.content}\n`);
+        }
+    }
+    if (mentalModel && mmText.length > 0) {
+        parts.push('\n\n## Mental Model (validate before acting)\n' +
+            `${MENTAL_MODEL_VALIDATION_PREFIX}\n\n` +
+            mmText);
+    }
+    const systemPrompt = parts.join('');
+    const model = TIER_MODELS[currentTier];
+    return {
+        agentName: agent.name,
+        resolvedTier: currentTier,
+        escalated,
+        declaredTier: agent.tier,
+        systemPrompt,
+        systemPromptTokens: estimateTokens(systemPrompt),
+        model: model.primary,
+        fallbackModels: model.fallbacks,
+        skills: agent.skills,
+        tools: agent.tools,
+        injectedContextSources: contextSlices.map((s) => s.source),
+        mentalModelInjected: mentalModel !== null && mmText.length > 0,
+    };
+}

package/dist/hierarchy.d.ts

@@ -0,0 +1,95 @@
+/**
+ * 3-tier hierarchy enforcement module — Wave 7.
+ *
+ * Enforces the CLEO agent hierarchy at spawn time per ULTRAPLAN section 10.
+ * Three roles (orchestrator, lead, worker) have strictly defined routing
+ * rules and tool restrictions:
+ *
+ *   - Orchestrators dispatch to leads only; cannot use Edit/Write/Bash.
+ *   - Leads dispatch to own-group workers only; cannot use Edit/Write/Bash.
+ *   - Workers cannot dispatch agents; may only query peers.
+ *
+ * @packageDocumentation
+ */
+/** Agent role within the 3-tier hierarchy. */
+export type Role = 'orchestrator' | 'lead' | 'worker';
+/**
+ * Routing rules for a team definition.
+ *
+ * Controls which agents each role tier may communicate with. The
+ * `orchestratorCanCall` and `leadCanCall` fields accept either a keyword
+ * shorthand (`'leads'` / `'own_group_workers'`) or an explicit list of
+ * agent names for fine-grained control.
+ */
+export interface TeamRouting {
+    /** The human-in-the-loop target agent name. */
+    hitlTarget: string;
+    /** Who the orchestrator may dispatch to: all leads or a named subset. */
+    orchestratorCanCall: 'leads' | string[];
+    /** Who a lead may dispatch to: own group workers or a named subset. */
+    leadCanCall: 'own_group_workers' | string[];
+    /** Explicit list of agents a worker may dispatch (typically empty). */
+    workerCanCall: string[];
+    /** Who workers may query: all peers or a named subset. */
+    workerCanQuery: 'peers' | string[];
+}
+/**
+ * Full team definition describing the hierarchy, group membership, and
+ * routing rules for an agent team.
+ */
+export interface TeamDefinition {
+    /** Human-readable team name. */
+    name: string;
+    /** Name of the orchestrator agent. */
+    orchestrator: string;
+    /** Map of group name to lead agent name. */
+    leads: Record<string, string>;
+    /** Map of group name to worker agent names. */
+    workers: Record<string, string[]>;
+    /** Routing rules governing inter-agent dispatch. */
+    routing: TeamRouting;
+    /** Enforcement mode: strict rejects violations, permissive logs warnings. */
+    enforcement: 'strict' | 'permissive';
+}
+/** Forbidden tools for lead-role agents (ULTRAPLAN section 10.4 LEAD-001). */
+export declare const LEAD_FORBIDDEN_TOOLS: readonly ["Edit", "Write", "Bash"];
+/** Forbidden tools for orchestrator-role agents (ULTRAPLAN section 10.5 ORCH-001). */
+export declare const ORCHESTRATOR_FORBIDDEN_TOOLS: readonly ["Edit", "Write", "Bash"];
+/**
+ * Result of a spawn validation check.
+ */
+export interface SpawnValidation {
+    /** Whether the spawn is allowed. */
+    allowed: boolean;
+    /** Human-readable reason for the decision. */
+    reason: string;
+}
+/**
+ * Validate whether a caller agent is allowed to spawn a target agent
+ * per the team's routing rules.
+ *
+ * Routing constraints (ULTRAPLAN section 10.2):
+ *   - Orchestrator may only dispatch to leads.
+ *   - Lead may only dispatch to workers within their own group.
+ *   - Workers may never dispatch agents (peer queries only).
+ *
+ * @param callerName - Name of the agent requesting the spawn.
+ * @param callerRole - Role of the calling agent.
+ * @param targetName - Name of the agent to be spawned.
+ * @param targetRole - Role of the target agent.
+ * @param team       - The team definition containing routing rules.
+ * @returns A {@link SpawnValidation} indicating whether the spawn is allowed.
+ */
+export declare function validateSpawnRequest(callerName: string, callerRole: Role, targetName: string, _targetRole: Role, team: TeamDefinition): SpawnValidation;
+/**
+ * Filter a tool list based on role constraints.
+ *
+ * Leads and orchestrators have Edit, Write, and Bash stripped per
+ * ULTRAPLAN sections 10.4 (LEAD-001) and 10.5 (ORCH-001). Workers
+ * retain all tools.
+ *
+ * @param tools - The full list of tool names available to the agent.
+ * @param role  - The agent's role in the hierarchy.
+ * @returns The filtered tool list with forbidden tools removed.
+ */
+export declare function filterToolsForRole(tools: string[], role: Role): string[];

package/dist/hierarchy.js

@@ -0,0 +1,103 @@
+"use strict";
+/**
+ * 3-tier hierarchy enforcement module — Wave 7.
+ *
+ * Enforces the CLEO agent hierarchy at spawn time per ULTRAPLAN section 10.
+ * Three roles (orchestrator, lead, worker) have strictly defined routing
+ * rules and tool restrictions:
+ *
+ *   - Orchestrators dispatch to leads only; cannot use Edit/Write/Bash.
+ *   - Leads dispatch to own-group workers only; cannot use Edit/Write/Bash.
+ *   - Workers cannot dispatch agents; may only query peers.
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ORCHESTRATOR_FORBIDDEN_TOOLS = exports.LEAD_FORBIDDEN_TOOLS = void 0;
+exports.validateSpawnRequest = validateSpawnRequest;
+exports.filterToolsForRole = filterToolsForRole;
+/** Forbidden tools for lead-role agents (ULTRAPLAN section 10.4 LEAD-001). */
+exports.LEAD_FORBIDDEN_TOOLS = ['Edit', 'Write', 'Bash'];
+/** Forbidden tools for orchestrator-role agents (ULTRAPLAN section 10.5 ORCH-001). */
+exports.ORCHESTRATOR_FORBIDDEN_TOOLS = ['Edit', 'Write', 'Bash'];
+// ---------------------------------------------------------------------------
+// Spawn validation
+// ---------------------------------------------------------------------------
+/**
+ * Validate whether a caller agent is allowed to spawn a target agent
+ * per the team's routing rules.
+ *
+ * Routing constraints (ULTRAPLAN section 10.2):
+ *   - Orchestrator may only dispatch to leads.
+ *   - Lead may only dispatch to workers within their own group.
+ *   - Workers may never dispatch agents (peer queries only).
+ *
+ * @param callerName - Name of the agent requesting the spawn.
+ * @param callerRole - Role of the calling agent.
+ * @param targetName - Name of the agent to be spawned.
+ * @param targetRole - Role of the target agent.
+ * @param team       - The team definition containing routing rules.
+ * @returns A {@link SpawnValidation} indicating whether the spawn is allowed.
+ */
+function validateSpawnRequest(callerName, callerRole, targetName, _targetRole, team) {
+    // Orchestrator can call leads
+    if (callerRole === 'orchestrator') {
+        const isLead = Object.values(team.leads).includes(targetName);
+        if (!isLead) {
+            return {
+                allowed: false,
+                reason: `Orchestrator ${callerName} can only dispatch to leads. ${targetName} is not a lead.`,
+            };
+        }
+        return { allowed: true, reason: 'Orchestrator dispatching to lead' };
+    }
+    // Lead can call own-group workers
+    if (callerRole === 'lead') {
+        const callerGroup = Object.entries(team.leads).find(([, name]) => name === callerName)?.[0];
+        if (!callerGroup) {
+            return {
+                allowed: false,
+                reason: `Lead ${callerName} not found in any team group`,
+            };
+        }
+        const groupWorkers = team.workers[callerGroup] ?? [];
+        if (!groupWorkers.includes(targetName)) {
+            return {
+                allowed: false,
+                reason: `Lead ${callerName} (group: ${callerGroup}) cannot dispatch to ${targetName} — not in own worker group`,
+            };
+        }
+        return {
+            allowed: true,
+            reason: `Lead dispatching to own-group worker (${callerGroup})`,
+        };
+    }
+    // Workers cannot dispatch
+    if (callerRole === 'worker') {
+        return {
+            allowed: false,
+            reason: `Worker ${callerName} cannot dispatch agents. Workers may only query peers.`,
+        };
+    }
+    return { allowed: false, reason: 'Unknown caller role' };
+}
+// ---------------------------------------------------------------------------
+// Tool filtering
+// ---------------------------------------------------------------------------
+/**
+ * Filter a tool list based on role constraints.
+ *
+ * Leads and orchestrators have Edit, Write, and Bash stripped per
+ * ULTRAPLAN sections 10.4 (LEAD-001) and 10.5 (ORCH-001). Workers
+ * retain all tools.
+ *
+ * @param tools - The full list of tool names available to the agent.
+ * @param role  - The agent's role in the hierarchy.
+ * @returns The filtered tool list with forbidden tools removed.
+ */
+function filterToolsForRole(tools, role) {
+    if (role === 'worker')
+        return tools;
+    const forbidden = role === 'lead' ? exports.LEAD_FORBIDDEN_TOOLS : exports.ORCHESTRATOR_FORBIDDEN_TOOLS;
+    return tools.filter((t) => !forbidden.includes(t));
+}

package/dist/index.d.ts

@@ -1,6 +1,14 @@
 export type { LAFSEnvelope, LAFSError, LAFSMeta, MVILevel } from '@cleocode/lafs';
+export type { AgentEntry, BundleDiagnostic, CompiledBundle, ParsedCantDocument, TeamEntry, ToolEntry, } from './bundle';
+export { compileBundle } from './bundle';
+export type { AgentDefinition, ContextProvider, ContextSlice, MentalModelSlice, SpawnPayload, Tier, } from './composer.js';
+export { composeSpawnPayload, escalateTier, estimateTokens, TIER_CAPS } from './composer.js';
 export type { CantDocumentResult, CantListResult, CantPipelineResult, CantValidationResult, SectionKind, } from './document';
 export { executePipeline, listSections, parseDocument, validateDocument, } from './document';
+export type { Role, SpawnValidation, TeamDefinition, TeamRouting } from './hierarchy.js';
+export { filterToolsForRole, LEAD_FORBIDDEN_TOOLS, ORCHESTRATOR_FORBIDDEN_TOOLS, validateSpawnRequest, } from './hierarchy.js';
+export type { ConsolidateOptions, MentalModel, MentalModelObservation, MentalModelScope, MentalModelStore, ObservationTrigger, SessionOutput, } from './mental-model.js';
+export { consolidate, createEmptyModel, harvestObservations, renderMentalModel, } from './mental-model.js';
 export type { ConvertedFile, MigrationOptions, MigrationResult, UnconvertedSection, } from './migrate/index';
 export { migrateMarkdown, serializeCantDocument, showDiff, showSummary } from './migrate/index';
 export type { NativeDiagnostic, NativeParseDocumentResult, NativeParseError, NativeParseResult, NativePipelineResult, NativePipelineStep, NativeValidateResult, } from './native-loader';
@@ -8,3 +16,5 @@ export { cantClassifyDirectiveNative, cantExecutePipelineNative, cantExtractAgen
 export type { ParsedCANTMessage } from './parse';
 export { initCantParser, parseCANTMessage } from './parse';
 export type { DirectiveType } from './types';
+export type { MergeResult, WorktreeConfig, WorktreeEntry, WorktreeHandle, WorktreeRequest, } from './worktree.js';
+export { createWorktree, listWorktrees, mergeWorktree, resolveWorktreeRoot, } from './worktree.js';

package/dist/index.js

@@ -1,12 +1,33 @@
 "use strict";
+// JIT Agent Composer (ULTRAPLAN Wave 5)
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseCANTMessage = exports.initCantParser = exports.isWasmAvailable = exports.isNativeAvailable = exports.initWasm = exports.cantValidateDocumentNative = exports.cantParseNative = exports.cantParseDocumentNative = exports.cantExtractAgentProfilesNative = exports.cantExecutePipelineNative = exports.cantClassifyDirectiveNative = exports.showSummary = exports.showDiff = exports.serializeCantDocument = exports.migrateMarkdown = exports.validateDocument = exports.parseDocument = exports.listSections = exports.executePipeline = void 0;
+exports.resolveWorktreeRoot = exports.mergeWorktree = exports.listWorktrees = exports.createWorktree = exports.parseCANTMessage = exports.initCantParser = exports.isWasmAvailable = exports.isNativeAvailable = exports.initWasm = exports.cantValidateDocumentNative = exports.cantParseNative = exports.cantParseDocumentNative = exports.cantExtractAgentProfilesNative = exports.cantExecutePipelineNative = exports.cantClassifyDirectiveNative = exports.showSummary = exports.showDiff = exports.serializeCantDocument = exports.migrateMarkdown = exports.renderMentalModel = exports.harvestObservations = exports.createEmptyModel = exports.consolidate = exports.validateSpawnRequest = exports.ORCHESTRATOR_FORBIDDEN_TOOLS = exports.LEAD_FORBIDDEN_TOOLS = exports.filterToolsForRole = exports.validateDocument = exports.parseDocument = exports.listSections = exports.executePipeline = exports.TIER_CAPS = exports.estimateTokens = exports.escalateTier = exports.composeSpawnPayload = exports.compileBundle = void 0;
+// Bundle compiler
+var bundle_1 = require("./bundle");
+Object.defineProperty(exports, "compileBundle", { enumerable: true, get: function () { return bundle_1.compileBundle; } });
+var composer_js_1 = require("./composer.js");
+Object.defineProperty(exports, "composeSpawnPayload", { enumerable: true, get: function () { return composer_js_1.composeSpawnPayload; } });
+Object.defineProperty(exports, "escalateTier", { enumerable: true, get: function () { return composer_js_1.escalateTier; } });
+Object.defineProperty(exports, "estimateTokens", { enumerable: true, get: function () { return composer_js_1.estimateTokens; } });
+Object.defineProperty(exports, "TIER_CAPS", { enumerable: true, get: function () { return composer_js_1.TIER_CAPS; } });
 // High-level API (replaces standalone cant-cli binary)
 var document_1 = require("./document");
 Object.defineProperty(exports, "executePipeline", { enumerable: true, get: function () { return document_1.executePipeline; } });
 Object.defineProperty(exports, "listSections", { enumerable: true, get: function () { return document_1.listSections; } });
 Object.defineProperty(exports, "parseDocument", { enumerable: true, get: function () { return document_1.parseDocument; } });
 Object.defineProperty(exports, "validateDocument", { enumerable: true, get: function () { return document_1.validateDocument; } });
+// 3-tier hierarchy enforcement (ULTRAPLAN Wave 7)
+var hierarchy_js_1 = require("./hierarchy.js");
+Object.defineProperty(exports, "filterToolsForRole", { enumerable: true, get: function () { return hierarchy_js_1.filterToolsForRole; } });
+Object.defineProperty(exports, "LEAD_FORBIDDEN_TOOLS", { enumerable: true, get: function () { return hierarchy_js_1.LEAD_FORBIDDEN_TOOLS; } });
+Object.defineProperty(exports, "ORCHESTRATOR_FORBIDDEN_TOOLS", { enumerable: true, get: function () { return hierarchy_js_1.ORCHESTRATOR_FORBIDDEN_TOOLS; } });
+Object.defineProperty(exports, "validateSpawnRequest", { enumerable: true, get: function () { return hierarchy_js_1.validateSpawnRequest; } });
+// Mental Model Manager (ULTRAPLAN Wave 8)
+var mental_model_js_1 = require("./mental-model.js");
+Object.defineProperty(exports, "consolidate", { enumerable: true, get: function () { return mental_model_js_1.consolidate; } });
+Object.defineProperty(exports, "createEmptyModel", { enumerable: true, get: function () { return mental_model_js_1.createEmptyModel; } });
+Object.defineProperty(exports, "harvestObservations", { enumerable: true, get: function () { return mental_model_js_1.harvestObservations; } });
+Object.defineProperty(exports, "renderMentalModel", { enumerable: true, get: function () { return mental_model_js_1.renderMentalModel; } });
 // Migration engine
 var index_1 = require("./migrate/index");
 Object.defineProperty(exports, "migrateMarkdown", { enumerable: true, get: function () { return index_1.migrateMarkdown; } });
@@ -28,3 +49,9 @@ Object.defineProperty(exports, "isWasmAvailable", { enumerable: true, get: funct
 var parse_1 = require("./parse");
 Object.defineProperty(exports, "initCantParser", { enumerable: true, get: function () { return parse_1.initCantParser; } });
 Object.defineProperty(exports, "parseCANTMessage", { enumerable: true, get: function () { return parse_1.parseCANTMessage; } });
+// Worktree isolation (ULTRAPLAN Wave 9)
+var worktree_js_1 = require("./worktree.js");
+Object.defineProperty(exports, "createWorktree", { enumerable: true, get: function () { return worktree_js_1.createWorktree; } });
+Object.defineProperty(exports, "listWorktrees", { enumerable: true, get: function () { return worktree_js_1.listWorktrees; } });
+Object.defineProperty(exports, "mergeWorktree", { enumerable: true, get: function () { return worktree_js_1.mergeWorktree; } });
+Object.defineProperty(exports, "resolveWorktreeRoot", { enumerable: true, get: function () { return worktree_js_1.resolveWorktreeRoot; } });