@inixiative/foundry-core 0.3.0 → 0.5.0

package/src/model-registry.ts

@@ -23,6 +23,30 @@ export type ProviderType =
   | 'custom';
 export type RuntimeKind = 'api' | 'native-harness' | 'typed-decision';
 
+/** Who trains the models a provider serves. Gateways and local hosts serve many labs and carry none. */
+export type ModelLab =
+  | 'anthropic'
+  | 'openai'
+  | 'google'
+  | 'meta'
+  | 'xai'
+  | 'deepseek'
+  | 'moonshot'
+  | 'zhipu'
+  | 'alibaba'
+  | 'mistral'
+  | 'typesafe';
+
+/** Labs whose models may run a main thread (the Artificer), on whatever transport reaches them. */
+export const MAIN_THREAD_LABS = [
+  'anthropic',
+  'openai',
+  'google',
+  'meta',
+  'xai',
+] as const satisfies readonly ModelLab[];
+export type MainThreadLab = (typeof MAIN_THREAD_LABS)[number];
+
 /**
  * What a model is worth using for. Every model is a judgment client — that is
  * not a provider category, it is a tag every entry carries. The other tags name
@@ -175,6 +199,8 @@ const MUSE_REASONING: ModelReasoning = {
 export interface FoundryProviderInfo {
   id: string;
   type: ProviderType;
+  /** Absent for gateways and local hosts. */
+  lab?: ModelLab;
   label: string;
   description: string;
   envKey?: string;
@@ -199,11 +225,17 @@ export interface ModelSweepOption {
 export const MODEL_REGISTRY_UPDATED_AT = '2026-09-24';
 
 /**
- * Decision default: the cheapest current model tagged `judgment`. Held here
- * rather than in an adapter so one map answers "what runs decisions".
+ * Decision default: Claude Haiku 5.5, the cheapest current Claude model tagged `judgment`. Held here
+ * rather than in an adapter so one map answers "what runs decisions". DECISION_PROVIDER is the
+ * API-token path; subscription decisions pick their model per runtime from SUBSCRIPTION_DECISION_MODELS.
  */
-export const DECISION_PROVIDER = 'openai';
-export const DECISION_MODEL = 'gpt-6-luna';
+export const DECISION_PROVIDER = 'anthropic';
+export const DECISION_MODEL = 'claude-haiku-5-5';
+/** Subscription decision default per native runtime; settings choose the runtime. */
+export const SUBSCRIPTION_DECISION_MODELS = {
+  claude: DECISION_MODEL,
+  codex: 'gpt-6-luna',
+} as const;
 
 /** Tag rule: every model judges. Cheap models review and route; capable models execute and advise. */
 const FAST = ['judgment', 'learning-review', 'tool-use'] as ModelCapability[];
@@ -222,6 +254,7 @@ const POWERFUL_REASONING = [...POWERFUL, 'reasoning'] as ModelCapability[];
 export const MODEL_REGISTRY: Record<string, FoundryProviderInfo> = {
   'claude-code': {
     id: 'claude-code',
+    lab: 'anthropic',
     type: 'claude-code',
     label: 'Claude Code (CLI subscription)',
     description: "Native Claude Code harness using the user's authenticated subscription.",
@@ -243,7 +276,7 @@ export const MODEL_REGISTRY: Record<string, FoundryProviderInfo> = {
       },
       {
         id: 'opus',
-        label: 'Opus 5',
+        label: 'Opus 5.5',
         tier: 'powerful',
         costTier: 'high',
         contextWindow: 1_000_000,
@@ -251,10 +284,11 @@ export const MODEL_REGISTRY: Record<string, FoundryProviderInfo> = {
         nativeAlias: true,
         capabilities: POWERFUL_REASONING,
         reasoning: CLAUDE_REASONING,
+        notes: 'Claude Code alias for claude-opus-5-5.',
       },
       {
         id: 'sonnet',
-        label: 'Sonnet 5',
+        label: 'Sonnet 5.5',
         tier: 'standard',
         costTier: 'medium',
         contextWindow: 1_000_000,
@@ -262,13 +296,46 @@ export const MODEL_REGISTRY: Record<string, FoundryProviderInfo> = {
         nativeAlias: true,
         capabilities: STANDARD_REASONING,
         reasoning: CLAUDE_REASONING,
+        notes: 'Claude Code alias for claude-sonnet-5-5.',
+      },
+      {
+        id: 'claude-haiku-5-5',
+        label: 'Haiku 5.5',
+        tier: 'fast',
+        costTier: 'low',
+        contextWindow: 1_000_000,
+        runtimeKind: 'native-harness',
+        capabilities: FAST_REASONING,
+        reasoning: { ...CLAUDE_REASONING, efforts: ['low', 'medium', 'high'] },
+        notes: "Foundry's decision model; the CLI reports this id as the served model.",
+      },
+      {
+        id: 'claude-opus-5-5',
+        label: 'Opus 5.5',
+        tier: 'powerful',
+        costTier: 'high',
+        contextWindow: 1_000_000,
+        runtimeKind: 'native-harness',
+        capabilities: POWERFUL_REASONING,
+        reasoning: CLAUDE_REASONING,
+      },
+      {
+        id: 'claude-fable-5-1',
+        label: 'Fable 5.1',
+        tier: 'powerful',
+        costTier: 'high',
+        contextWindow: 1_000_000,
+        maxOutputTokens: 128_000,
+        runtimeKind: 'native-harness',
+        capabilities: POWERFUL_REASONING,
+        reasoning: CLAUDE_REASONING,
       },
       {
         id: 'haiku',
-        label: 'Haiku 4.5',
+        label: 'Haiku 5.5',
         tier: 'fast',
         costTier: 'low',
-        contextWindow: 200_000,
+        contextWindow: 1_000_000,
         runtimeKind: 'native-harness',
         nativeAlias: true,
         capabilities: FAST_REASONING,
@@ -278,6 +345,7 @@ export const MODEL_REGISTRY: Record<string, FoundryProviderInfo> = {
   },
   anthropic: {
     id: 'anthropic',
+    lab: 'anthropic',
     type: 'anthropic',
     label: 'Anthropic (API key)',
     description: 'Direct Anthropic API access without the Claude Code native harness.',
@@ -297,6 +365,17 @@ export const MODEL_REGISTRY: Record<string, FoundryProviderInfo> = {
         reasoning: CLAUDE_REASONING,
         notes: 'Thinking is always on; steer with effort.',
       },
+      {
+        id: 'claude-opus-5-5',
+        label: 'Claude Opus 5.5',
+        tier: 'powerful',
+        costTier: 'high',
+        contextWindow: 1_000_000,
+        maxOutputTokens: 128_000,
+        runtimeKind: 'api',
+        capabilities: POWERFUL_REASONING,
+        reasoning: CLAUDE_REASONING,
+      },
       {
         id: 'claude-opus-5',
         label: 'Claude Opus 5',
@@ -319,6 +398,18 @@ export const MODEL_REGISTRY: Record<string, FoundryProviderInfo> = {
         capabilities: STANDARD_REASONING,
         reasoning: CLAUDE_REASONING,
       },
+      {
+        id: 'claude-haiku-5-5',
+        label: 'Claude Haiku 5.5',
+        tier: 'fast',
+        costTier: 'low',
+        contextWindow: 1_000_000,
+        maxOutputTokens: 128_000,
+        runtimeKind: 'api',
+        capabilities: FAST_REASONING,
+        reasoning: { ...CLAUDE_REASONING, efforts: ['low', 'medium', 'high'] },
+      },
+      // Previous generation, still served.
       {
         id: 'claude-haiku-4-5',
         label: 'Claude Haiku 4.5',
@@ -330,7 +421,6 @@ export const MODEL_REGISTRY: Record<string, FoundryProviderInfo> = {
         reasoning: { ...CLAUDE_REASONING, efforts: ['low', 'medium', 'high'] },
         notes: 'Takes a thinking budget, not an effort ladder.',
       },
-      // Previous generation, still served.
       {
         id: 'claude-fable-5',
         label: 'Claude Fable 5',
@@ -390,6 +480,7 @@ export const MODEL_REGISTRY: Record<string, FoundryProviderInfo> = {
   },
   codex: {
     id: 'codex',
+    lab: 'openai',
     type: 'codex',
     label: 'Codex CLI (OpenAI subscription)',
     description: "Native Codex harness using the user's authenticated OpenAI/Codex subscription.",
@@ -480,6 +571,7 @@ export const MODEL_REGISTRY: Record<string, FoundryProviderInfo> = {
   },
   openai: {
     id: 'openai',
+    lab: 'openai',
     type: 'openai',
     label: 'OpenAI',
     description: 'OpenAI API models for classification, routing, and execution.',
@@ -575,6 +667,7 @@ export const MODEL_REGISTRY: Record<string, FoundryProviderInfo> = {
   },
   gemini: {
     id: 'gemini',
+    lab: 'google',
     type: 'gemini',
     label: 'Google Gemini',
     description: 'Gemini API models for high-volume agent work.',
@@ -641,6 +734,7 @@ export const MODEL_REGISTRY: Record<string, FoundryProviderInfo> = {
   },
   meta: {
     id: 'meta',
+    lab: 'meta',
     type: 'openai-compatible',
     // Llama is not Meta's frontier line any more; Muse Spark replaced it in April 2026
     // and there is no "Llama 5". The open-weight Llama entries under openrouter,
@@ -721,6 +815,7 @@ export const MODEL_REGISTRY: Record<string, FoundryProviderInfo> = {
   },
   xai: {
     id: 'xai',
+    lab: 'xai',
     type: 'xai',
     label: 'xAI (Grok)',
     description:
@@ -803,6 +898,7 @@ export const MODEL_REGISTRY: Record<string, FoundryProviderInfo> = {
   },
   deepseek: {
     id: 'deepseek',
+    lab: 'deepseek',
     type: 'openai-compatible',
     label: 'DeepSeek',
     description:
@@ -839,6 +935,7 @@ export const MODEL_REGISTRY: Record<string, FoundryProviderInfo> = {
   },
   kimi: {
     id: 'kimi',
+    lab: 'moonshot',
     type: 'openai-compatible',
     label: 'Kimi (Moonshot AI)',
     description: 'Moonshot Kimi models. OpenAI-compatible; temperature range is 0-1, not 0-2.',
@@ -893,6 +990,7 @@ export const MODEL_REGISTRY: Record<string, FoundryProviderInfo> = {
   },
   glm: {
     id: 'glm',
+    lab: 'zhipu',
     type: 'openai-compatible',
     label: 'GLM (Z.ai / Zhipu)',
     description:
@@ -1030,6 +1128,7 @@ export const MODEL_REGISTRY: Record<string, FoundryProviderInfo> = {
   },
   qwen: {
     id: 'qwen',
+    lab: 'alibaba',
     type: 'openai-compatible',
     label: 'Qwen (Alibaba Model Studio)',
     // The legacy static domain still works; Alibaba now recommends the per-workspace
@@ -1439,6 +1538,7 @@ export const MODEL_REGISTRY: Record<string, FoundryProviderInfo> = {
   },
   mistral: {
     id: 'mistral',
+    lab: 'mistral',
     type: 'openai-compatible',
     label: 'Mistral AI',
     description:
@@ -1507,6 +1607,7 @@ export const MODEL_REGISTRY: Record<string, FoundryProviderInfo> = {
   },
   typesafe: {
     id: 'typesafe',
+    lab: 'typesafe',
     type: 'typesafe',
     label: 'TypeSafe (Jev)',
     description:
@@ -1565,6 +1666,14 @@ export function providersWithCapability(capability: ModelCapability): FoundryPro
   );
 }
 
+/** The main-thread lab a provider serves, or undefined when it serves none (or many). */
+export function mainThreadLab(providerId: string): MainThreadLab | undefined {
+  const lab = MODEL_REGISTRY[providerId]?.lab;
+  return (MAIN_THREAD_LABS as readonly string[]).includes(lab ?? '')
+    ? (lab as MainThreadLab)
+    : undefined;
+}
+
 /** The part of a Foundry configuration `resolveDecisionModel` reads. */
 export interface DecisionModelDefaults {
   defaults: {

package/src/native-evidence.ts

@@ -167,7 +167,7 @@ export interface NativeBridgeLease {
   readonly toolPolicy?: NativeToolPolicy;
   /** Private, empty native cwd owned by a restricted fixture lease. */
   readonly fixtureCwd?: string;
-  readonly launch: { readonly claudeJson: string; readonly codexOverrides: readonly string[] };
+  readonly launch: { readonly claudeJson: string };
   check(): void;
   register(evidence: NativeEvidence): void;
   observe(evidence: NativeEvidence): void;
@@ -194,7 +194,17 @@ export interface NativeObservation {
   register(evidence: NativeEvidence): void | Promise<void>;
   /** Fallible observer; never vetoes executor completion. */
   observe(evidence: NativeEvidence): void | Promise<void>;
+  /** Receives the stop for this owner's registered admission, where the runtime acknowledges stops. */
+  interruptible?(interrupt: NativeInterrupt): void;
+  /**
+   * The executor's public thinking text, for live display only. It never becomes evidence:
+   * nothing here is journalled, traced or projected (reasoning stays out of NativeEvidence).
+   */
+  thought?(text: string): void;
 }
+/** `acknowledged`: the runtime confirmed the stop and the turn reached its native terminal. */
+export type NativeInterruptOutcome = 'acknowledged' | 'no-turn' | 'unacknowledged';
+export type NativeInterrupt = (opts?: { timeoutMs?: number }) => Promise<NativeInterruptOutcome>;
 export function freezeEvidence<T>(value: T): T {
   const copy = structuredClone(value);
   const freeze = (v: unknown) => {

package/src/scope.ts

@@ -9,6 +9,8 @@
 export interface OwnershipScope {
   readonly threadId?: string;
   readonly projectId?: string;
+  /** Where the thread's native session runs. Not ownership: sources that read the workspace resolve against it. */
+  readonly cwd?: string;
 }
 
 /** Copy a scope, dropping undefined fields so equality checks are stable. */

package/src/session-delivery.ts

@@ -0,0 +1,76 @@
+import { computeHash } from './context-layer';
+import type { PromptBlock } from './context-stack';
+
+/** One standing part of a thread's context (a layer with its prompt, or the agent's own prompt), keyed by content hash. */
+export interface StandingPart {
+  readonly id: string;
+  readonly hash: string;
+  readonly text: string;
+}
+
+/**
+ * A turn's context split for a provider that keeps a native session. Standing parts go into the
+ * session's system prompt once, when the session starts; afterwards only parts whose hash differs
+ * from what the session holds are sent with the turn. The per-turn text is sent every turn.
+ */
+export interface SessionDelivery {
+  /** Every standing part, in context order. */
+  readonly standing: readonly StandingPart[];
+  /** Per-turn context (routing, Warden advice); sent with every turn. */
+  readonly turn: string;
+  /**
+   * The thread's delivery ledger: part id → hash the session holds from an earlier turn's message.
+   * Cleared on compaction, reset when a session starts.
+   */
+  readonly held: Readonly<Record<string, string>>;
+}
+
+export interface DeliveredPart {
+  readonly id: string;
+  readonly hash: string;
+}
+
+/** What a session provider actually delivered for one turn. */
+export interface SessionDeliveryReport {
+  /** "started": this turn ran on a session that started with `base` as its system prompt. */
+  readonly session: 'started' | 'held';
+  /** The parts the session's system prompt carries. */
+  readonly base: readonly DeliveredPart[];
+  /** Standing parts sent in this turn's message because the session did not hold their hash. */
+  readonly sent: readonly DeliveredPart[];
+  /**
+   * A started session that resumed the conversation the thread's ledger describes (a relaunch in
+   * this process): the ledger still holds, so it is kept and extended rather than reset.
+   */
+  readonly ledgerKept?: true;
+}
+
+/** Group assembled layer blocks (a layer's prompt block, then its content block) into standing parts. */
+export function standingParts(blocks: readonly PromptBlock[]): StandingPart[] {
+  const parts: Array<{ id: string; texts: string[] }> = [];
+  for (const block of blocks) {
+    const id = block.id ?? `${block.role}:${parts.length}`;
+    const last = parts.at(-1);
+    if (last && last.id === id) last.texts.push(block.text);
+    else parts.push({ id, texts: [block.text] });
+  }
+  // Two layers may share an id (a configured layer and a runtime-owned one); each is its own part.
+  const seen = new Map<string, number>();
+  return parts.map(({ id, texts }) => {
+    const n = (seen.get(id) ?? 0) + 1;
+    seen.set(id, n);
+    return standingPart(n === 1 ? id : `${id}#${n}`, texts.join('\n\n'));
+  });
+}
+
+/** A warm layer as the standing part the executor assembles: its prompt, then its content. */
+export function layerPart(layer: { id: string; prompt?: string; content: string }): StandingPart {
+  return standingPart(
+    layer.id,
+    layer.prompt ? `${layer.prompt}\n\n${layer.content}` : layer.content,
+  );
+}
+
+export function standingPart(id: string, text: string): StandingPart {
+  return { id, hash: computeHash(text), text };
+}

package/src/thread.ts

@@ -125,6 +125,14 @@ export interface DispatchOptions {
   messageId?: string;
   /** How the caller invoked the agent: always, conditional, on-demand, background. */
   invocation?: string;
+  /**
+   * What the agent itself receives when it differs from the payload that middleware and the
+   * dispatch observation read: a host's instruction wrappers go to the agent verbatim, while
+   * everything that learns from the message sees only the user's words.
+   */
+  agentPayload?: unknown;
+  /** Lets this dispatch's middleware include an on-demand layer in its assembly (`RequestContext.requestLayer`). */
+  requestLayer?: (layerId: string) => void;
 }
 
 /**
@@ -355,6 +363,7 @@ export class Thread {
       stack: this._createStackView(),
       projectId: this.meta.projectId,
       messageId: opts?.messageId,
+      ...(opts?.requestLayer ? { requestLayer: opts.requestLayer } : {}),
     };
 
     const start = performance.now();
@@ -398,6 +407,8 @@ export class Thread {
             bridge: opts.nativeObservation.bridge,
             register: opts.nativeObservation.register,
             observe: opts.nativeObservation.observe,
+            interruptible: opts.nativeObservation.interruptible,
+            thought: opts.nativeObservation.thought,
             owner: Object.freeze({
               threadId: this.id,
               projectId: this.meta.projectId,
@@ -411,7 +422,11 @@ export class Thread {
 
     try {
       const result = await this.middleware.execute(ctx, () =>
-        agent.run(payload, filterOverride, meta),
+        agent.run(
+          opts?.agentPayload !== undefined ? (opts.agentPayload as TPayload) : payload,
+          filterOverride,
+          meta,
+        ),
       );
 
       const durationMs = performance.now() - start;
@@ -548,11 +563,11 @@ export class Thread {
     return {
       hasLayer: (id) => {
         const l = stack.getLayer(id);
-        return l ? l.isWarm : false;
+        return l ? l.assemblable : false;
       },
       getContent: (id) => {
         const l = stack.getLayer(id);
-        return l?.isWarm ? l.content : '';
+        return l?.assemblable ? l.content : '';
       },
       getState: (id) => stack.getLayer(id)?.state,
       get layerIds() {

package/src/types.ts

@@ -114,6 +114,12 @@ export interface CompletionOpts {
    * cached prefix; others ignore it. Messages are sent unchanged either way.
    */
   stablePrefix?: string;
+  /**
+   * The executor's context split into standing parts and per-turn text. A provider that keeps a
+   * native session delivers standing parts once and then only what changed (session-delivery.ts);
+   * others ignore it and send the messages unchanged.
+   */
+  delivery?: import('./session-delivery').SessionDelivery;
 }
 
 export interface CompletionResult {
@@ -125,6 +131,8 @@ export interface CompletionResult {
   /** Tool calls requested by the LLM (present when finishReason is "tool_use"). */
   readonly toolCalls?: ToolCall[];
   readonly raw?: unknown;
+  /** What a session provider delivered when it used `CompletionOpts.delivery`. */
+  readonly delivery?: import('./session-delivery').SessionDeliveryReport;
 }
 
 export interface EmbeddingResult {

package/src/permission-middleware.ts

@@ -1,80 +0,0 @@
-import { type Capability, CapabilityDeniedError, type CapabilityGate } from './capability';
-import type { DispatchContext, Middleware, MiddlewareNext } from './middleware';
-
-export interface PermissionCheckResult {
-  action: 'allow' | 'deny' | 'ask';
-  /** Optional modified payload (like Claude Code's updatedInput). */
-  modifiedPayload?: unknown;
-  /** Reason for denial. */
-  reason?: string;
-}
-
-export interface PermissionCheck {
-  /** Which capability this check relates to. */
-  capability: Capability;
-  /** Narrow the check to specific agents. If omitted, applies to all. */
-  agentIds?: string[];
-  /** Custom check logic beyond the gate. */
-  check: (ctx: DispatchContext) => PermissionCheckResult | Promise<PermissionCheckResult>;
-}
-
-export interface PermissionMiddlewareConfig {
-  /** The capability gate to check against. */
-  gate: CapabilityGate;
-  /** Thread ID for prompt context. */
-  threadId: string;
-  /** Default capability to check for all dispatches. Default: "llm:call". */
-  defaultCapability?: Capability;
-  /** Additional custom permission checks. */
-  checks?: PermissionCheck[];
-}
-
-/**
- * Creates a middleware that checks permissions before dispatch.
- *
- * Integrates the existing CapabilityGate into the dispatch pipeline.
- * Records permission decisions in ctx.annotations.
- */
-export function permissionMiddleware(config: PermissionMiddlewareConfig): Middleware {
-  const { gate, threadId, defaultCapability = 'llm:call', checks } = config;
-
-  return async (ctx: DispatchContext, next: MiddlewareNext) => {
-    // Check default capability via gate
-    const resolution = await gate.check(defaultCapability, {
-      agentId: ctx.agentId,
-      threadId,
-      detail: `Dispatch to agent ${ctx.agentId}`,
-    });
-
-    if (resolution.action === 'rejected') {
-      ctx.annotations['permission:denied'] = true;
-      ctx.annotations['permission:capability'] = defaultCapability;
-      throw new CapabilityDeniedError(defaultCapability, 'deny');
-    }
-
-    ctx.annotations['permission:approved'] = true;
-    ctx.annotations['permission:by'] = resolution.by;
-
-    // Run custom checks
-    if (checks) {
-      for (const check of checks) {
-        if (check.agentIds && !check.agentIds.includes(ctx.agentId)) continue;
-
-        const result = await check.check(ctx);
-
-        if (result.action === 'deny') {
-          ctx.annotations['permission:denied'] = true;
-          ctx.annotations['permission:capability'] = check.capability;
-          ctx.annotations['permission:reason'] = result.reason;
-          throw new CapabilityDeniedError(check.capability, 'deny');
-        }
-
-        if (result.modifiedPayload !== undefined) {
-          ctx.annotations['permission:modifiedPayload'] = result.modifiedPayload;
-        }
-      }
-    }
-
-    return next();
-  };
-}