@fenixforce/kernel 0.1.0

package/dist/memory/markdown-store.d.ts

@@ -0,0 +1,64 @@
+import type { Note } from "./note-parser.js";
+import type { MetadataFilters } from "./metadata-filter.js";
+export interface FileSystem {
+    readFile(path: string): Promise<string>;
+    writeFile(path: string, content: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    listFiles(dir: string, pattern?: string): Promise<string[]>;
+}
+export interface NoteIndex {
+    upsert(permalink: string, metadata: Record<string, unknown>): Promise<void>;
+    remove(permalink: string): Promise<void>;
+    search(query: string, filters?: MetadataFilters, limit?: number): Promise<NoteIndexResult[]>;
+    getByPermalink(permalink: string): Promise<NoteIndexResult | null>;
+}
+export interface NoteIndexResult {
+    permalink: string;
+    metadata: Record<string, unknown>;
+    score?: number;
+}
+export interface FileWatcher {
+    watch(dir: string, handler: (filePath: string, event: "change" | "add" | "delete") => void): () => void;
+}
+export interface MarkdownStoreConfig {
+    /** Root directory for markdown files. */
+    rootDir: string;
+    /** File system adapter. */
+    fs: FileSystem;
+    /** Database index for search. */
+    index: NoteIndex;
+    /** Optional file watcher for auto-reindex on external edits. */
+    watcher?: FileWatcher;
+}
+export type MarkdownStoreEventType = "note:written" | "note:read" | "note:reindexed" | "note:deleted";
+export interface MarkdownStoreEvent {
+    type: MarkdownStoreEventType;
+    permalink: string;
+    timestamp: number;
+}
+export type MarkdownStoreEventHandler = (event: MarkdownStoreEvent) => void;
+export declare class MarkdownStore {
+    private config;
+    private handlers;
+    private watchDisposer?;
+    constructor(config: MarkdownStoreConfig);
+    /** Write a note: serialize to Markdown, write file, upsert DB index. */
+    write(note: Note): Promise<void>;
+    /** Read a note from file (source of truth, not DB). */
+    read(permalink: string): Promise<Note | null>;
+    /** Search: DB for search, file for content. */
+    search(query: string, filters?: MetadataFilters, limit?: number): Promise<Note[]>;
+    /** Traverse [[WikiLinks]] to specified depth. */
+    traverse(permalink: string, depth: number): Promise<Note[]>;
+    /** Delete a note and remove from index. */
+    delete(permalink: string): Promise<void>;
+    /** Subscribe to store events. */
+    on(handler: MarkdownStoreEventHandler): () => void;
+    /** Stop file watcher and clean up. */
+    dispose(): void;
+    private traverseRecursive;
+    private reindexFile;
+    private permalinkToFilePath;
+    private filePathToPermalink;
+    private emit;
+}

package/dist/memory/metadata-filter.d.ts

@@ -0,0 +1,29 @@
+export type FilterValue = string | number | boolean | {
+    $in: (string | number)[];
+} | {
+    $gt: number | string;
+} | {
+    $gte: number | string;
+} | {
+    $lt: number | string;
+} | {
+    $lte: number | string;
+} | {
+    $between: [number | string, number | string];
+} | (string | number)[];
+export type MetadataFilters = Record<string, FilterValue>;
+export interface SQLClause {
+    where: string;
+    params: unknown[];
+}
+/**
+ * Convert MetadataFilters to a PostgreSQL WHERE clause against
+ * a jsonb column. Dot notation maps to -> / ->> operators.
+ * All filters are AND-combined.
+ */
+export declare function filtersToSQL(filters: MetadataFilters, column?: string, paramOffset?: number): SQLClause;
+/**
+ * Evaluate MetadataFilters against an in-memory metadata object.
+ * Returns true if all filters match.
+ */
+export declare function matchesFilters(metadata: Record<string, unknown>, filters: MetadataFilters): boolean;

package/dist/memory/mid-conversation-saves.d.ts

@@ -0,0 +1,17 @@
+import type { StorageAdapter, MemorySegment } from "../storage/interface.js";
+import type { AgentEvent } from "../events/types.js";
+export interface ImmediateSaveInput {
+    userId: string;
+    content: string;
+    immediate: true;
+    tags: string[];
+}
+export interface ImmediateSaveContext {
+    sessionId?: string;
+}
+/**
+ * Save a fact directly into MTM, bypassing the async consolidation pipeline.
+ * Uses "fact" category with baseline heat for immediate persistence.
+ */
+export declare function immediateMemorySave(storage: StorageAdapter, input: ImmediateSaveInput): Promise<MemorySegment>;
+export declare function immediateMemorySaveWithEvents(storage: StorageAdapter, input: ImmediateSaveInput, context?: ImmediateSaveContext): AsyncGenerator<AgentEvent, MemorySegment>;

package/dist/memory/note-parser.d.ts

@@ -0,0 +1,34 @@
+export interface NoteFrontmatter {
+    title: string;
+    type?: string;
+    tags?: string[];
+    permalink: string;
+    status?: string;
+    confidence?: number;
+    [key: string]: unknown;
+}
+export interface Observation {
+    category: string;
+    content: string;
+    tags: string[];
+    context?: string;
+}
+export interface NoteRelation {
+    relationType: string;
+    targetPermalink: string;
+}
+export interface Note {
+    frontmatter: NoteFrontmatter;
+    body: string;
+    observations: Observation[];
+    relations: NoteRelation[];
+    raw: string;
+}
+export declare function parseFrontmatter(raw: string): {
+    frontmatter: Record<string, unknown>;
+    body: string;
+};
+export declare function parseObservations(body: string): Observation[];
+export declare function parseRelations(body: string): NoteRelation[];
+export declare function parseNote(raw: string): Note;
+export declare function serializeNote(note: Note): string;

package/dist/memory/observation-store.d.ts

@@ -0,0 +1,36 @@
+import type { StorageAdapter, Observation } from "../storage/interface.js";
+import type { AgentEvent } from "../events/types.js";
+export type ObservationCategory = "factual" | "procedural" | "error" | "preference";
+export interface ObservationInput {
+    userId: string;
+    conversationId: string;
+    content: string;
+    category: ObservationCategory;
+    /** Optional source tool name */
+    source?: string;
+}
+export interface ObservationStoreConfig {
+    /** Number of accesses before auto-promoting to MTM */
+    autoPromoteThreshold: number;
+    /** Whether to generate embeddings for observations */
+    generateEmbeddings: boolean;
+}
+export declare const DEFAULT_OBSERVATION_CONFIG: ObservationStoreConfig;
+export declare function resetAccessCounts(): void;
+/**
+ * Record a new observation from a tool result or user interaction.
+ */
+export declare function recordObservation(storage: StorageAdapter, input: ObservationInput, config?: ObservationStoreConfig): Promise<Observation>;
+/**
+ * Retrieve observations for a user, tracking access counts.
+ * Observations that exceed the auto-promote threshold are promoted to MTM.
+ */
+export declare function retrieveObservations(storage: StorageAdapter, userId: string, config?: ObservationStoreConfig): Promise<{
+    observations: Observation[];
+    promoted: string[];
+}>;
+export declare function recordObservationWithEvents(storage: StorageAdapter, input: ObservationInput, config?: ObservationStoreConfig, sessionId?: string): AsyncGenerator<AgentEvent, Observation>;
+export declare function retrieveObservationsWithEvents(storage: StorageAdapter, userId: string, config?: ObservationStoreConfig, sessionId?: string): AsyncGenerator<AgentEvent, {
+    observations: Observation[];
+    promoted: string[];
+}>;

package/dist/memory/observation-thresholds.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Observation thresholds — checks whether pending observations have
+ * crossed review thresholds during session orient.
+ *
+ * Detects tensions: pairs of pending observations in the same category
+ * whose content appears contradictory (one contains a negation keyword
+ * relative to the other).
+ */
+import type { StorageAdapter, Observation } from "../storage/interface.js";
+export interface ObservationReviewConfig {
+    /** Number of pending observations that triggers a review. */
+    pendingThreshold: number;
+    /** Number of detected tensions that triggers a review. */
+    tensionThreshold: number;
+    /** When true, automatically surface review if any threshold is met. */
+    autoSurface: boolean;
+}
+export declare const DEFAULT_REVIEW_CONFIG: ObservationReviewConfig;
+export interface ObservationReviewResult {
+    shouldReview: boolean;
+    pendingCount: number;
+    tensions: Observation[];
+}
+/** Two observations in the same category are in tension if one contains a negation word the other lacks. */
+export declare function detectTensions(observations: Observation[]): Observation[];
+export declare function checkObservationThresholds(storage: StorageAdapter, userId: string, config?: ObservationReviewConfig): Promise<ObservationReviewResult>;

package/dist/memory/progressive-search.d.ts

@@ -0,0 +1,25 @@
+export interface SearchResult {
+    id: string;
+    content: string;
+    relevance: number;
+    source: "keyword" | "embedding";
+}
+export interface ProgressiveSearchConfig {
+    localHitThreshold: number;
+    localHitMinResults: number;
+    maxResults: number;
+}
+export type KeywordSearchFn = (query: string, limit: number) => Promise<SearchResult[]>;
+export type EmbeddingSearchFn = (query: string, limit: number) => Promise<SearchResult[]>;
+export declare class ProgressiveSearch {
+    readonly config: ProgressiveSearchConfig;
+    private keywordSearch;
+    private embeddingSearch;
+    constructor(keywordSearch: KeywordSearchFn, embeddingSearch: EmbeddingSearchFn, config?: Partial<ProgressiveSearchConfig>);
+    search(query: string): Promise<{
+        results: SearchResult[];
+        skippedEmbedding: boolean;
+    }>;
+    meetsLocalHitThreshold(results: SearchResult[]): boolean;
+    private mergeResults;
+}

package/dist/memory/synthesis.d.ts

@@ -0,0 +1,36 @@
+import type { StorageAdapter } from "../storage/interface.js";
+export interface TaskDiary {
+    id: string;
+    userId: string;
+    conversationId: string;
+    taskType: string;
+    /** Structured log of what happened during execution */
+    entries: DiaryEntry[];
+    /** Whether this diary has been synthesized */
+    synthesized: boolean;
+    createdAt: Date;
+}
+export interface DiaryEntry {
+    timestamp: string;
+    action: string;
+    result: "success" | "failure" | "skipped";
+    detail?: string;
+}
+export interface SynthesisResult {
+    patterns: SynthesizedPattern[];
+    diariesProcessed: number;
+}
+export interface SynthesizedPattern {
+    content: string;
+    category: string;
+    confidence: number;
+}
+export type LLMSynthesizeFn = (prompt: string) => Promise<string>;
+export declare const TASK_DIARY_SCHEMA = "\nCREATE TABLE IF NOT EXISTS task_diaries (\n  id TEXT PRIMARY KEY,\n  user_id TEXT NOT NULL,\n  conversation_id TEXT NOT NULL,\n  task_type TEXT NOT NULL,\n  entries JSONB NOT NULL DEFAULT '[]',\n  synthesized BOOLEAN NOT NULL DEFAULT false,\n  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()\n);\n\nCREATE INDEX IF NOT EXISTS idx_task_diaries_user\n  ON task_diaries (user_id, synthesized);\nCREATE INDEX IF NOT EXISTS idx_task_diaries_type\n  ON task_diaries (task_type);\n";
+export declare function writeTaskDiary(storage: StorageAdapter, input: {
+    userId: string;
+    conversationId: string;
+    taskType: string;
+    entries: DiaryEntry[];
+}): Promise<TaskDiary>;
+export declare function synthesizeMemories(storage: StorageAdapter, userId: string, llmSynthesize: LLMSynthesizeFn): Promise<SynthesisResult>;

package/dist/memory/tree-index.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Tree-Indexed RAG — vectorless reasoning-based retrieval using
+ * a hierarchical JSON tree index navigated by an LLM.
+ *
+ * Instead of embedding cosine distance, the LLM reads node summaries
+ * and decides which branch to descend. Ideal for structured corpora:
+ * language courses (800K+ words, 229 languages), financial reports,
+ * legal documents, technical manuals.
+ *
+ * Two phases:
+ *   1. Index generation (one-time, uses utility LLM)
+ *   2. Tree search (per query, uses chat LLM)
+ */
+export interface TreeNode {
+    /** Unique node identifier. */
+    id: string;
+    /** Human-readable summary of this subtree's content. */
+    summary: string;
+    /** Page/section range this node covers, e.g. "1-50" or "lessons 1-10". */
+    pageRange: string;
+    /** Child nodes (empty for leaf nodes). */
+    children: TreeNode[];
+    /** Full text content (leaf nodes only, null for branch nodes). */
+    content: string | null;
+}
+export interface TreeIndex {
+    /** Root node of the tree. */
+    root: TreeNode;
+    /** Source document identifier (links to content_sources). */
+    sourceId: string;
+    /** When this index was generated. */
+    createdAt: Date;
+    /** Total number of leaf nodes. */
+    leafCount: number;
+}
+export interface NavigationStep {
+    /** Node ID visited at this step. */
+    nodeId: string;
+    /** Summary of the node. */
+    summary: string;
+    /** LLM reasoning for selecting this branch. */
+    reasoning: string;
+    /** Depth level (0 = root). */
+    depth: number;
+}
+export interface TreeSearchResult {
+    /** The answer synthesized from leaf content. */
+    answer: string;
+    /** Navigation path from root to selected leaf(s). */
+    path: NavigationStep[];
+    /** Leaf nodes selected as relevant. */
+    leafNodes: TreeNode[];
+    /** Total LLM calls made during navigation. */
+    llmCalls: number;
+}
+/** Utility LLM for index generation: summarize text into a short summary. */
+export type SummarizeFn = (text: string, context?: string) => Promise<string>;
+/**
+ * Chat LLM for tree navigation: given a query and child summaries,
+ * return the indices (0-based) of children to descend into.
+ */
+export type NavigateFn = (query: string, childSummaries: Array<{
+    index: number;
+    summary: string;
+    pageRange: string;
+}>) => Promise<{
+    selectedIndices: number[];
+    reasoning: string;
+}>;
+export type TreeEventType = "index_start" | "index_node_created" | "index_done" | "retrieval:tree_step" | "retrieval:search_start" | "retrieval:search_done";
+export interface TreeEvent {
+    type: TreeEventType;
+    timestamp: Date;
+    nodeId?: string;
+    detail: string;
+}
+export type TreeEventListener = (event: TreeEvent) => void;
+export interface TreeIndexConfig {
+    /** LLM for summarization during index building. */
+    summarize: SummarizeFn;
+    /** LLM for navigation during search. */
+    navigate: NavigateFn;
+    /** Max children per internal node. Default 8. */
+    maxChildrenPerNode?: number;
+    /** Max characters per leaf chunk. Default 2000. */
+    maxLeafChars?: number;
+    /** Max tree depth for search traversal. Default 10. */
+    maxDepth?: number;
+}
+export interface TreeIndexManager {
+    /** Build a tree index from a document. */
+    buildIndex(sourceId: string, text: string): Promise<TreeIndex>;
+    /** Search a tree index with LLM-guided navigation. */
+    search(index: TreeIndex, query: string): Promise<TreeSearchResult>;
+    /** Serialize a tree index to JSON for storage. */
+    serialize(index: TreeIndex): string;
+    /** Deserialize a tree index from stored JSON. */
+    deserialize(json: string): TreeIndex;
+    /** Events. */
+    on(listener: TreeEventListener): void;
+    off(listener: TreeEventListener): void;
+}
+export declare function _resetTreeIds(): void;
+export declare function createTreeIndexManager(config: TreeIndexConfig): TreeIndexManager;

package/dist/memory/write-gate.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Write Gate + Temporal Validity — prevents memory bloat by gating
+ * what gets persisted to medium-term memory (MTM).
+ *
+ * Write Gate: Before persisting any observation to MTM, apply a
+ * lightweight utility LLM call: "Will this change how the agent
+ * reasons in future sessions?" Binary yes/no. Includes redundancy
+ * detection: merges observations expressing the same insight.
+ *
+ * Temporal Validity: Facts can expire or be superseded. Memory
+ * search filters out invalidated facts by default.
+ *
+ * ~80 lines of logic.
+ */
+import type { LLMProvider } from "../providers/interface.js";
+/** Temporal metadata attached to memory segments and knowledge graph relations. */
+export interface TemporalValidity {
+    /** When this fact became valid (defaults to creation time). */
+    validFrom: Date;
+    /** When this fact was invalidated/superseded (null if still valid). */
+    invalidatedAt: Date | null;
+    /** ID of the observation that superseded this one, if any. */
+    supersededBy: string | null;
+}
+export interface WriteGateInput {
+    /** The new observation content to evaluate. */
+    content: string;
+    /** Category of the observation. */
+    category: string;
+    /** User ID (for scoping existing memories). */
+    userId: string;
+}
+export interface WriteGateResult {
+    /** Whether the observation should be persisted. */
+    persist: boolean;
+    /** Reason for the decision. */
+    reason: string;
+    /** If a redundant existing observation was found, its ID. */
+    mergeWith?: string;
+    /** Merged content if combining with existing observation. */
+    mergedContent?: string;
+}
+/** Existing memory entry for redundancy checking. */
+export interface ExistingMemory {
+    id: string;
+    content: string;
+    category: string;
+}
+export type FetchExistingFn = (userId: string) => Promise<ExistingMemory[]>;
+export interface WriteGateConfig {
+    /** Utility LLM provider for gate decisions. */
+    provider: LLMProvider;
+    /** Function to fetch existing memories for redundancy check. */
+    fetchExisting: FetchExistingFn;
+}
+export declare function evaluateWriteGate(input: WriteGateInput, config: WriteGateConfig): Promise<WriteGateResult>;
+export declare function createTemporalValidity(validFrom?: Date): TemporalValidity;
+export declare function invalidate(tv: TemporalValidity, supersededBy?: string): TemporalValidity;
+export declare function isValid(tv: TemporalValidity, asOf?: Date): boolean;
+/** Filter a list of items with temporal validity, keeping only valid ones. */
+export declare function filterValid<T extends {
+    temporal?: TemporalValidity;
+}>(items: T[], asOf?: Date): T[];

package/dist/mission-control.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Mission Control — convenience wrapper around the Dashboard API.
+ * Provides a factory that wires the dashboard with sensible defaults
+ * for port, base path, and a logActivity shorthand.
+ */
+import type { Dashboard, DashboardConfig } from "./api/dashboard.js";
+import type { ActivityEntry } from "./api/dashboard.js";
+export interface MissionControlConfig {
+    /** Dashboard configuration. */
+    dashboard?: DashboardConfig;
+    /** Port to serve the dashboard API. Default 3100. */
+    port?: number;
+    /** Base path for dashboard API. Default "/api/v1/dashboard". */
+    basePath?: string;
+    /** Auth token for dashboard access. */
+    authToken?: string;
+}
+export interface MissionControl {
+    /** The underlying dashboard instance. */
+    readonly dashboard: Dashboard;
+    /** Port the dashboard serves on. */
+    readonly port: number;
+    /** Base path. */
+    readonly basePath: string;
+    /** Log an activity event (convenience). */
+    logActivity(eventType: string, summary: string, opts?: {
+        channel?: string;
+        sessionId?: string;
+        status?: ActivityEntry["status"];
+        payload?: Record<string, unknown>;
+    }): ActivityEntry;
+}
+/** Create a Mission Control instance with dashboard wired up. */
+export declare function createMissionControl(config?: MissionControlConfig): MissionControl;

package/dist/pre-classifier-widgets.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Parallel Widgets — when the pre-classifier detects a query
+ * answerable by multiple independent data sources, dispatch
+ * parallel tool calls and render results as independent blocks.
+ *
+ * Example: "What's the weather, news, and AAPL stock?"
+ *   → 3 parallel widget fetches → 3 independent result blocks.
+ *
+ * ~60 lines of logic.
+ */
+import type { QueryClassification } from "./events/types.js";
+export interface WidgetSource {
+    /** Unique source identifier (e.g. "weather", "news", "stocks"). */
+    id: string;
+    /** Human-readable label. */
+    label: string;
+    /** Sub-query extracted for this source. */
+    query: string;
+}
+export interface WidgetResult {
+    /** Source that produced this result. */
+    sourceId: string;
+    /** Rendered content block. */
+    content: string;
+    /** Block type for structured rendering. */
+    blockType: "text" | "code" | "citation";
+    /** Whether this source succeeded. */
+    ok: boolean;
+    /** Error message if failed. */
+    error?: string;
+}
+export interface ParallelWidgetConfig {
+    /** Map of source ID → fetch function. */
+    sources: Map<string, (query: string) => Promise<string>>;
+    /** Maximum concurrent fetches. Default: 5. */
+    maxConcurrent?: number;
+}
+export type WidgetDetectFn = (query: string, classification: QueryClassification) => WidgetSource[];
+export declare function detectWidgetSources(query: string, classification: QueryClassification): WidgetSource[];
+export declare function dispatchWidgets(sources: WidgetSource[], config: ParallelWidgetConfig): Promise<WidgetResult[]>;

package/dist/pre-classifier.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Pre-Classifier (G26) — classifies incoming queries before the agent loop.
+ *
+ * Uses structured output (generateObject) to determine:
+ * - Query type (conversation, code, research, memory, creative)
+ * - Standalone rewrite for follow-up questions
+ * - Skip-agent flag for trivial queries answerable directly
+ *
+ * Yields query:classified event via the AgentLoopConfig.classifyQuery hook.
+ */
+import type { LLMProvider } from "./providers/interface.js";
+import type { QueryClassificationResult } from "./agent-loop.js";
+/**
+ * Create a pre-classifier function using the given provider.
+ * Returns a QueryClassifier compatible with AgentLoopConfig.classifyQuery.
+ */
+export declare function createPreClassifier(provider: LLMProvider): (query: string, context: {
+    turnNumber?: number;
+}) => Promise<QueryClassificationResult>;

package/dist/prompt/context-budget.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Context budget — allocates token budget across prompt sections
+ * with priority-based distribution and graceful degradation.
+ *
+ * V1 (backward-compatible): fixed 4-category allocation.
+ * V2 (lane-based): dynamic lanes with overflow policies (AIRI ContextUpdate).
+ *
+ * Priority allocation (after fixed identity block):
+ *   steering rules  20%
+ *   memories         40%
+ *   orient context   20%
+ *   brain artifacts  20%
+ *
+ * If a section is empty, its budget is redistributed proportionally
+ * among the remaining non-empty sections.
+ */
+export interface BudgetAllocation {
+    identity: number;
+    steeringRules: number;
+    memories: number;
+    orientContext: number;
+    brainArtifacts: number;
+    total: number;
+}
+export interface SectionSizes {
+    steeringRules: number;
+    memories: number;
+    orientContext: number;
+    brainArtifacts: number;
+}
+export interface ContextLane {
+    /** Unique lane identifier, e.g. "identity", "memory", "browser". */
+    id: string;
+    /** Module that owns this lane. */
+    source: string;
+    /** Fraction of totalTokens (0.0 to 1.0). */
+    budgetShare: number;
+    /** How content is managed: replace fully or append incrementally. */
+    strategy: "replace" | "append";
+    /** Current content for this lane. */
+    content: string;
+    /** Higher priority lanes get their full share first. */
+    priority: number;
+}
+export type OverflowPolicy = "trim-lowest-priority" | "proportional-shrink";
+export interface ContextBudgetV2 {
+    totalTokens: number;
+    defaultLanes: ContextLane[];
+    dynamicLanes: ContextLane[];
+    overflowPolicy: OverflowPolicy;
+}
+export declare function estimateTokens(text: string): number;
+export declare function allocateBudget(totalBudget: number, sectionSizes: SectionSizes): BudgetAllocation;
+export declare function truncateToTokenBudget(text: string, tokenBudget: number): string;
+export declare function createDefaultLanes(): ContextLane[];
+export declare function createBudgetV2(totalTokens: number, overflowPolicy?: OverflowPolicy): ContextBudgetV2;
+/** Register a dynamic lane at runtime (tools, extensions, skills). */
+export declare function registerLane(budget: ContextBudgetV2, lane: ContextLane): void;
+/** Remove a dynamic lane. */
+export declare function unregisterLane(budget: ContextBudgetV2, laneId: string): boolean;
+export interface LaneAllocation {
+    laneId: string;
+    tokenBudget: number;
+    content: string;
+    trimmed: boolean;
+}
+/** Allocate tokens across all lanes, applying overflow policy when needed. */
+export declare function allocateLanes(budget: ContextBudgetV2): LaneAllocation[];

package/dist/prompt/index.d.ts

@@ -0,0 +1,3 @@
+export { ANTI_VERBOSITY_MINIMAL, ANTI_VERBOSITY_NORMAL, ANTI_VERBOSITY_DETAILED, VERBOSITY_TEMPLATES, INSTRUCTION_HIERARCHY, BASE_IDENTITY, type VerbosityLevel, } from "./templates.js";
+export { allocateBudget, estimateTokens, truncateToTokenBudget, type BudgetAllocation, type SectionSizes, } from "./context-budget.js";
+export { buildSystemPrompt, type SystemPromptInput, } from "./system-prompt.js";

package/dist/prompt/system-prompt.d.ts

@@ -0,0 +1,32 @@
+/**
+ * System prompt builder — assembles the full system prompt from all
+ * context sources with token budget enforcement.
+ *
+ * Budget allocation (configurable, default 4,000 tokens):
+ *   Identity block:       800 tokens (from identity files)
+ *   LPM traits:           400 tokens (user profile / long-term preferences)
+ *   MTM memories:       1,600 tokens (mid-term memory segments)
+ *   Steering rules:       remaining (always + active conditional)
+ *   Anti-verbosity:       fixed (not counted against budget)
+ *   Tool descriptions:    fixed (not counted against budget)
+ *   Mode instructions:    fixed (not counted against budget)
+ *   Brain artifacts:      shares MTM budget overflow
+ */
+import type { AgentMode } from "../events/types.js";
+import type { ToolDefinition as LLMToolDefinition } from "../providers/interface.js";
+import type { UserProfile, MemorySegment, BrainArtifact, IdentityFile } from "../storage/interface.js";
+import type { OrientResult } from "../session-orient.js";
+import type { VerbosityLevel } from "./templates.js";
+export interface SystemPromptInput {
+    verbosity: VerbosityLevel;
+    mode: AgentMode;
+    tools: LLMToolDefinition[];
+    profile: UserProfile | null;
+    memories: MemorySegment[];
+    orient: OrientResult;
+    steeringRules: string[];
+    identityFiles?: IdentityFile[];
+    brainArtifacts?: BrainArtifact[];
+    tokenBudget?: number;
+}
+export declare function buildSystemPrompt(input: SystemPromptInput): string;

package/dist/prompt/templates.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Prompt template strings — anti-verbosity presets, identity block,
+ * and instruction hierarchy markers.
+ */
+export type VerbosityLevel = "minimal" | "normal" | "detailed";
+export declare const ANTI_VERBOSITY_MINIMAL: string;
+export declare const ANTI_VERBOSITY_NORMAL: string;
+export declare const ANTI_VERBOSITY_DETAILED: string;
+export declare const VERBOSITY_TEMPLATES: Record<VerbosityLevel, string>;
+export declare const INSTRUCTION_HIERARCHY: string;
+export declare const BASE_IDENTITY: string;