@inixiative/foundry-core 0.2.0 → 0.4.0

package/src/hooks.ts

@@ -3,22 +3,22 @@
 // ---------------------------------------------------------------------------
 
 export type HookPoint =
-  | "pre:dispatch"
-  | "post:dispatch"
-  | "pre:classify"
-  | "post:classify"
-  | "pre:route"
-  | "post:route"
-  | "pre:compact"
-  | "post:compact"
-  | "session:create"
-  | "session:archive"
-  | "budget:warning"
-  | "budget:exceeded"
-  | "plan:enter"
-  | "plan:exit"
-  | "error:agent"
-  | "error:provider";
+  | 'pre:dispatch'
+  | 'post:dispatch'
+  | 'pre:classify'
+  | 'post:classify'
+  | 'pre:route'
+  | 'post:route'
+  | 'pre:compact'
+  | 'post:compact'
+  | 'session:create'
+  | 'session:archive'
+  | 'budget:warning'
+  | 'budget:exceeded'
+  | 'plan:enter'
+  | 'plan:exit'
+  | 'error:agent'
+  | 'error:provider';
 
 export interface HookContext {
   hookPoint: HookPoint;
@@ -31,7 +31,7 @@ export interface HookContext {
 }
 
 export interface HookResult {
-  action: "continue" | "skip" | "abort" | "redirect";
+  action: 'continue' | 'skip' | 'abort' | 'redirect';
   redirectTo?: string;
   modified?: Partial<HookContext>;
   annotations?: Record<string, unknown>;
@@ -45,7 +45,7 @@ export interface HookHandler {
 }
 
 export interface PlanModeTrigger {
-  kind: "complexity" | "newDomain" | "largeDiff" | "custom";
+  kind: 'complexity' | 'newDomain' | 'largeDiff' | 'custom';
   threshold?: number;
   detect?: (ctx: HookContext) => boolean;
 }
@@ -67,7 +67,9 @@ export class HookRegistry {
 
   register(handler: HookHandler): () => void {
     this._handlers.set(handler.id, handler);
-    return () => { this._handlers.delete(handler.id); };
+    return () => {
+      this._handlers.delete(handler.id);
+    };
   }
 
   unregister(id: string): boolean {
@@ -76,11 +78,11 @@ export class HookRegistry {
 
   async execute(
     point: HookPoint,
-    ctx: HookContext
-  ): Promise<HookContext & { action: HookResult["action"] }> {
+    ctx: HookContext,
+  ): Promise<HookContext & { action: HookResult['action'] }> {
     const handlers = this.forPoint(point);
     let current = { ...ctx };
-    let action: HookResult["action"] = "continue";
+    let action: HookResult['action'] = 'continue';
 
     for (const handler of handlers) {
       const result = await handler.handler(current);
@@ -102,7 +104,7 @@ export class HookRegistry {
         current.meta = { ...current.meta, redirectTo: result.redirectTo };
       }
 
-      if (action === "abort" || action === "skip" || action === "redirect") {
+      if (action === 'abort' || action === 'skip' || action === 'redirect') {
         break;
       }
     }
@@ -117,9 +119,7 @@ export class HookRegistry {
         matching.push(handler);
       }
     }
-    matching.sort(
-      (a, b) => (a.priority ?? DEFAULT_PRIORITY) - (b.priority ?? DEFAULT_PRIORITY)
-    );
+    matching.sort((a, b) => (a.priority ?? DEFAULT_PRIORITY) - (b.priority ?? DEFAULT_PRIORITY));
     return matching;
   }
 

package/src/hydrator.ts

@@ -1,4 +1,4 @@
-import type { ContextSource } from "./context-layer";
+import type { ContextSource } from './context-layer';
 
 /**
  * A ref is a pointer into a knowledge system.
@@ -106,7 +106,7 @@ export class HydrationRegistry {
    * Returns concatenated content in ref order.
    */
   async hydrateAll(refs: ContextRef[]): Promise<string> {
-    if (refs.length === 0) return "";
+    if (refs.length === 0) return '';
 
     // Group by system
     const bySystem = new Map<string, { idx: number; ref: ContextRef }[]>();
@@ -127,9 +127,7 @@ export class HydrationRegistry {
         }
 
         if (adapter.hydrateBatch && entries.length > 1) {
-          const batchResults = await adapter.hydrateBatch(
-            entries.map((e) => e.ref)
-          );
+          const batchResults = await adapter.hydrateBatch(entries.map((e) => e.ref));
           for (let i = 0; i < entries.length; i++) {
             results[entries[i].idx] = batchResults[i];
           }
@@ -137,12 +135,12 @@ export class HydrationRegistry {
           await Promise.all(
             entries.map(async (entry) => {
               results[entry.idx] = await adapter.hydrate(entry.ref);
-            })
+            }),
           );
         }
-      })
+      }),
     );
 
-    return results.join("\n\n");
+    return results.join('\n\n');
   }
 }

package/src/id.ts

@@ -1,4 +1,4 @@
-import { uuidv7 } from "uuidv7";
+import { uuidv7 } from 'uuidv7';
 
 /**
  * Mint a new UUID v7 identifier, optionally prefixed.
@@ -26,14 +26,14 @@ export function idAtTime(prefix: string | undefined, date: Date): string {
   if (ms < 0 || ms > 0xffffffffffff) {
     throw new RangeError(`timestamp ${ms} out of UUID v7 range`);
   }
-  const hex = ms.toString(16).padStart(12, "0");
+  const hex = ms.toString(16).padStart(12, '0');
   const uuid = `${hex.slice(0, 8)}-${hex.slice(8, 12)}-7000-8000-000000000000`;
   return prefix ? `${prefix}_${uuid}` : uuid;
 }
 
 /** Extract the millisecond timestamp encoded in a UUID v7 id (with or without prefix). */
 export function timeFromId(id: string): number {
-  const uuid = id.includes("_") ? id.slice(id.lastIndexOf("_") + 1) : id;
+  const uuid = id.includes('_') ? id.slice(id.lastIndexOf('_') + 1) : id;
   const hex = uuid.slice(0, 8) + uuid.slice(9, 13);
   return parseInt(hex, 16);
 }

package/src/index.ts

@@ -2,272 +2,306 @@
 // @inixiative/foundry-core — the engine
 // ---------------------------------------------------------------------------
 
-// Shared types
-export type {
-  InvocationCondition,
-  AgentModeConfig,
-  LayerModeConfig,
-  LLMMessage,
-  CompletionOpts,
-  CompletionResult,
-  ToolDefinition,
-  ToolCall,
-  ToolCallResult,
-  EmbeddingResult,
-  LLMStreamEvent,
-  LLMProvider,
-  EmbeddingProvider,
-} from "./types";
-
-// Ownership scope — which thread/project owns a source read or tool call
-export { normalizeScope, type OwnershipScope } from "./scope";
-
-// Message utilities
+// Action Prompts (agent→human interaction)
 export {
-  assembledToMessages,
-  buildInjectionArtifact,
-  splitSystemMessage,
-  type BuildInjectionArtifactOpts,
-  type InjectionArtifact,
-  type InjectionBlock,
-  type InjectionSegmentKind,
-  type MessageDecoration,
-  type DecorationParticipant,
-  type ParticipantRequest,
-  type DeliveryRecord,
-} from "./messages";
-
+  type ActionOption,
+  type ActionPrompt,
+  ActionQueue,
+  type ActionResolution,
+  type PromptKind,
+  type PromptListener,
+  type PromptOpts,
+  type PromptPolicy,
+  type PromptStatus,
+  type PromptUrgency,
+} from './action-prompt';
+// Lightweight adapters (zero external deps)
+export {
+  DEFAULT_MEMORY_SELECTION,
+  entryVisibleTo,
+  FileMemory,
+  fileSource,
+  focusTerms,
+  inlineSource,
+  type MemoryEntry,
+  type MemoryReadScope,
+  type MemorySelectionPolicy,
+  type MemorySelectionReport,
+  type MemorySourceOpts,
+  MemoryView,
+  selectMemory,
+  validateMemorySelection,
+} from './adapters/file-memory';
+export { HttpMemory } from './adapters/http-memory';
+export { claudemdSource, MarkdownDocs } from './adapters/markdown-docs';
+export { type SqliteEntry, SqliteMemory } from './adapters/sqlite-memory';
+// Agent primitives
+export {
+  type AgentConfig,
+  type AgentLLMConfig,
+  BaseAgent,
+  type ExecutionResult,
+} from './base-agent';
+// Bounded data structures
+export { BoundedSet } from './bounded-set';
+export {
+  CacheLifecycle,
+  type LifecycleEvent,
+  type LifecycleHandler,
+  type LifecycleRule,
+} from './cache-lifecycle';
+// Capabilities (permission flags + gating)
+export {
+  BROWSER_POLICY,
+  type BuiltinCapability,
+  type Capability,
+  CapabilityDeniedError,
+  CapabilityGate,
+  type GateContext,
+  type PermissionLevel,
+  type PermissionPolicy,
+  RESTRICTED_POLICY,
+} from './capability';
+export {
+  type ClarificationResult,
+  Clarifier,
+  type ClarifierConfig,
+  type ClarifyHandler,
+  type ClarifyPayload,
+} from './clarifier';
+export {
+  type Classification,
+  Classifier,
+  type ClassifierConfig,
+  type ClassifyHandler,
+} from './classifier';
 // Context primitives
 export {
   ContextLayer,
+  type ContextLayerConfig,
+  type ContextSource,
   computeHash,
   copyMessageIdentity,
-  type LogicalMessageIdentity,
-  type ContextSource,
-  type ContextLayerConfig,
+  isLayerSegment,
+  LAYER_SEGMENTS,
   type LayerDefinition,
   type LayerInstanceState,
-  type LayerVersionMark,
-  type LayerSegment,
-  LAYER_SEGMENTS,
-  isLayerSegment,
   type LayerMutationEvent,
+  type LayerSegment,
   type LayerSelectionState,
   type LayerState,
+  type LayerVersionMark,
+  type LogicalMessageIdentity,
+  REQUIRED_CONTEXT_BLOCKED,
   type SourceLoadHint,
   type SourceSelectionReport,
   type VersionEntry,
   type VersionLog,
-} from "./context-layer";
-
+} from './context-layer';
 export {
-  ContextStack,
-  type LayerFilter,
+  type AssembledContext,
   type ContextSnapshot,
+  ContextStack,
   type ContextStackView,
+  type LayerFilter,
   type PromptBlock,
-  type AssembledContext,
-} from "./context-stack";
-
+} from './context-stack';
+export type { CredentialReference, CredentialResolver, CredentialScope } from './credentials';
+export { type DecideHandler, Decider, type DeciderConfig, type Decision } from './decider';
+export type {
+  DeliveryOwner,
+  ExpertDeliveryProof,
+  ProviderBoundaryReceipt,
+} from './delivery-evidence';
 export {
-  CacheLifecycle,
-  type LifecycleEvent,
-  type LifecycleHandler,
-  type LifecycleRule,
-} from "./cache-lifecycle";
+  assemblyDigest,
+  boundaryReceipt,
+  evidenceDigest,
+  verifyExpertDelivery,
+} from './delivery-evidence';
+// Observability
+export { EventStream, type SessionEvent, type StreamEvent } from './event-stream';
+export { type ExecuteHandler, type ExecuteMeta, Executor, type ExecutorConfig } from './executor';
+export {
+  type FlowConfig,
+  type FlowStage,
+  Harness,
+  type HarnessResult,
+  type Message,
+  matchesCondition,
+  type PipelineStep,
+  type RequestContext,
+} from './harness';
 
+// Lifecycle Hooks (registry only — built-in hooks in @inixiative/foundry)
+export {
+  type HookContext,
+  type HookHandler,
+  type HookPoint,
+  HookRegistry,
+  type HookResult,
+  type PlanModeConfig,
+  type PlanModeTrigger,
+} from './hooks';
 export {
-  HydrationRegistry,
-  RefSource,
   type ContextRef,
   type HydrationAdapter,
-} from "./hydrator";
-
-// Agent primitives
+  HydrationRegistry,
+  RefSource,
+} from './hydrator';
+// IDs (UUID v7 — carries its own creation timestamp)
+export { idAtTime, newId, timeFromId } from './id';
+// Interventions
+export { type Intervention, InterventionLog, type InterventionThread } from './intervention';
+// Message utilities
 export {
-  BaseAgent,
-  type ExecutionResult,
-  type AgentConfig,
-  type AgentLLMConfig,
-} from "./base-agent";
-
-export { Executor, type ExecuteHandler, type ExecuteMeta, type ExecutorConfig } from "./executor";
-export { Decider, type Decision, type DecideHandler, type DeciderConfig } from "./decider";
-export { Classifier, type Classification, type ClassifyHandler, type ClassifierConfig } from "./classifier";
-export { Router, type Route, type RouteHandler, type RouterConfig } from "./router";
-
+  assembledToMessages,
+  type BuildInjectionArtifactOpts,
+  buildInjectionArtifact,
+  type DecorationParticipant,
+  type DeliveryRecord,
+  type InjectionArtifact,
+  type InjectionBlock,
+  type InjectionSegmentKind,
+  type MessageDecoration,
+  type ParticipantRequest,
+  splitSystemMessage,
+} from './messages';
 // Middleware
 export {
-  MiddlewareChain,
-  type Middleware,
-  type MiddlewareTier,
-  type MiddlewareEntry,
   type DispatchContext,
   type DispatchOutcome,
+  type Middleware,
+  MiddlewareChain,
+  type MiddlewareEntry,
   type MiddlewareNext,
-} from "./middleware";
-
+  type MiddlewareTier,
+} from './middleware';
+export {
+  type CostTier,
+  DECISION_MODEL,
+  DECISION_PROVIDER,
+  type DecisionModelDefaults,
+  type FoundryModelInfo,
+  type FoundryProviderInfo,
+  MAIN_THREAD_LABS,
+  type MainThreadLab,
+  MODEL_CAPABILITIES,
+  MODEL_REGISTRY,
+  MODEL_REGISTRY_UPDATED_AT,
+  type ModelCapability,
+  type ModelLab,
+  type ModelReasoning,
+  type ModelSweepOption,
+  type ModelTier,
+  mainThreadLab,
+  modelCapabilities,
+  modelHasCapability,
+  modelOptionsByCapability,
+  type ProviderCredential,
+  type ProviderType,
+  providersWithCapability,
+  type ReasoningEffort,
+  type RuntimeKind,
+  registryModel,
+  resolveDecisionModel,
+} from './model-registry';
+export * from './native-evidence';
+// Permission middleware
+export {
+  type PermissionCheck,
+  type PermissionCheckResult,
+  type PermissionMiddlewareConfig,
+  permissionMiddleware,
+} from './permission-middleware';
+// Retry middleware
+export { type RetryConfig, retryMiddleware } from './retry';
+export { type Route, type RouteHandler, Router, type RouterConfig } from './router';
+// Ownership scope — which thread/project owns a source read or tool call
+export { normalizeScope, type OwnershipScope } from './scope';
 // Signals
-export { SignalBus, type Signal, type SignalKind, type SignalHandler } from "./signal";
-
+export { type Signal, SignalBus, type SignalHandler, type SignalKind } from './signal';
 // Orchestration
 export {
-  Thread,
-  type ThreadStatus,
-  type ThreadMeta,
-  type ThreadConfig,
   type Dispatch,
-  type DispatchOptions,
   type DispatchObservation,
+  type DispatchOptions,
   type FanResult,
-} from "./thread";
-
-export {
-  Harness,
-  matchesCondition,
-  type Message,
-  type HarnessResult,
-  type PipelineStep,
-  type FlowStage,
-  type FlowConfig,
-  type RequestContext,
-} from "./harness";
-
-// Tracing
-export { Trace, type Span, type SpanKind, type SpanStatus, type TraceSummary, type StageSummary } from "./trace";
-
-// Interventions
-export { InterventionLog, type Intervention } from "./intervention";
-
-// Observability
-export { EventStream, type StreamEvent, type SessionEvent } from "./event-stream";
-
+  Thread,
+  type ThreadConfig,
+  type ThreadContext,
+  type ThreadMeta,
+  type ThreadName,
+  type ThreadReference,
+  type ThreadStatus,
+  threadTitle,
+} from './thread';
+export { sumTokenCounts, type TokenCounts, totalTokenCount } from './token-counts';
 // Token & Cost Tracking
 export {
-  TokenTracker,
+  type BudgetConfig,
   BudgetExceededError,
-  estimateTokens,
+  type BudgetStatus,
+  type CostTable,
   DEFAULT_COST_TABLE,
-  type TokenUsage,
-  type UsageEntry,
+  estimateTokens,
   type ModelPricing,
-  type CostTable,
-  type BudgetConfig,
-  type BudgetStatus,
+  TokenTracker,
+  type TokenUsage,
   type UsageBreakdown,
+  type UsageEntry,
   type UsageSummary,
-} from "./token-tracker";
-
-// Lifecycle Hooks (registry only — built-in hooks in @inixiative/foundry)
-export {
-  HookRegistry,
-  type HookPoint,
-  type HookContext,
-  type HookResult,
-  type HookHandler,
-  type PlanModeConfig,
-  type PlanModeTrigger,
-} from "./hooks";
-
-// Action Prompts (agent→human interaction)
-export {
-  ActionQueue,
-  type ActionPrompt,
-  type ActionResolution,
-  type ActionOption,
-  type PromptKind,
-  type PromptUrgency,
-  type PromptStatus,
-  type PromptOpts,
-  type PromptListener,
-  type PromptPolicy,
-} from "./action-prompt";
-
-// Capabilities (permission flags + gating)
-export {
-  CapabilityGate,
-  CapabilityDeniedError,
-  UNATTENDED_POLICY,
-  SUPERVISED_POLICY,
-  RESTRICTED_POLICY,
-  BROWSER_POLICY,
-  type Capability,
-  type BuiltinCapability,
-  type PermissionLevel,
-  type PermissionPolicy,
-  type GateContext,
-} from "./capability";
-
-// Lightweight adapters (zero external deps)
-export {
-  FileMemory,
-  MemoryView,
-  entryVisibleTo,
-  inlineSource,
-  fileSource,
-  selectMemory,
-  focusTerms,
-  DEFAULT_MEMORY_SELECTION, validateMemorySelection,
-  type MemoryEntry,
-  type MemoryReadScope,
-  type MemorySourceOpts,
-  type MemorySelectionPolicy,
-  type MemorySelectionReport,
-} from "./adapters/file-memory";
-
-export { SqliteMemory, type SqliteEntry } from "./adapters/sqlite-memory";
-export { HttpMemory } from "./adapters/http-memory";
-export { MarkdownDocs, claudemdSource } from "./adapters/markdown-docs";
-
+} from './token-tracker';
 // Tools — typed execution interfaces
 export {
-  ToolRegistry,
-  type Tool,
-  type ToolKind,
-  type ToolInfo,
-  type ToolResult,
-  type ToolCallObservation,
-  type BrowserTool,
-  type PageSnapshot,
-  type PageElement,
-  type NavigateOpts,
-  type ApiTool,
   type ApiRequest,
   type ApiResponse,
+  type ApiTool,
   type ApiToolConfig,
-  type ShellTool,
-  type ShellResult,
-  type ShellOpts,
-  type OutputFilter,
-  type ScriptTool,
-  type ScriptResult,
-  type ScriptOpts,
-  type MemoryTool,
+  type BrowserTool,
   type MemoryEntry as ToolMemoryEntry,
-  type MemoryVisibility,
   type MemorySearchOpts,
-} from "./tools";
-
-// Bounded data structures
-export { BoundedSet } from "./bounded-set";
-
-// IDs (UUID v7 — carries its own creation timestamp)
-export { newId, idAtTime, timeFromId } from "./id";
-
-// Retry middleware
-export { retryMiddleware, type RetryConfig } from "./retry";
-
-// Permission middleware
+  type MemoryTool,
+  type MemoryVisibility,
+  type NavigateOpts,
+  type OutputFilter,
+  type PageElement,
+  type PageSnapshot,
+  type ScriptOpts,
+  type ScriptResult,
+  type ScriptTool,
+  type ShellOpts,
+  type ShellResult,
+  type ShellTool,
+  type Tool,
+  type ToolCallObservation,
+  type ToolInfo,
+  type ToolKind,
+  ToolRegistry,
+  type ToolResult,
+} from './tools';
+// Tracing
 export {
-  permissionMiddleware,
-  type PermissionMiddlewareConfig,
-  type PermissionCheck,
-  type PermissionCheckResult,
-} from "./permission-middleware";
-
-export { REQUIRED_CONTEXT_BLOCKED } from "./context-layer";
-export * from "./native-evidence";
-export type { CredentialReference, CredentialScope, CredentialResolver } from "./credentials";
-export { evidenceDigest, assemblyDigest, boundaryReceipt, verifyExpertDelivery } from "./delivery-evidence";
-export type { ProviderBoundaryReceipt, DeliveryOwner, ExpertDeliveryProof } from "./delivery-evidence";
-export { type TokenCounts, totalTokenCount, sumTokenCounts } from "./token-counts";
+  type Span,
+  type SpanKind,
+  type SpanStatus,
+  type StageSummary,
+  Trace,
+  type TraceSummary,
+} from './trace';
+// Shared types
+export type {
+  AgentModeConfig,
+  CompletionOpts,
+  CompletionResult,
+  EmbeddingProvider,
+  EmbeddingResult,
+  InvocationCondition,
+  LayerModeConfig,
+  LLMMessage,
+  LLMProvider,
+  LLMStreamEvent,
+  ToolCall,
+  ToolCallResult,
+  ToolDefinition,
+} from './types';