@inixiative/foundry-core 0.5.9 → 0.5.11

package/src/index.ts

@@ -140,6 +140,7 @@ export {
   type SourceSegment,
   type SourceSelectionReport,
   segmentsText,
+  sha256Hex,
   type VersionEntry,
   type VersionLog,
 } from './context-layer';
@@ -166,7 +167,13 @@ export {
 } 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 ExecuteHandler,
+  type ExecuteMeta,
+  Executor,
+  type ExecutorConfig,
+  withAfterMessageNotes,
+} from './executor';
 // Feedback: correction detection (the Prospector's), shared by Oracle, live capture and `foundry repeats`
 export {
   AGAIN_CORRECTION,
@@ -179,6 +186,7 @@ export {
   type CorrectionDetection,
   type CorrectionEvent,
   type CorrectionSignal,
+  contextSecretHits,
   correctionClassifyMessages,
   correctionId,
   detectCorrection,
@@ -187,6 +195,7 @@ export {
   type FeedbackTag,
   parseCorrectionClassifications,
   proseOf,
+  SHAPED_SECRET_PATTERNS,
   scrubSecrets,
   type TranscriptTurn,
 } from './feedback/correction';
@@ -292,16 +301,6 @@ export {
   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 {
   type ContextRef,
   type HydrationAdapter,
@@ -357,17 +356,20 @@ export {
   type ModelVendor,
   mainThreadLab,
   modelCapabilities,
+  modelEfforts,
   modelHasCapability,
   modelOptionsByCapability,
   type ProviderCredential,
   type ProviderMode,
   type ProviderType,
   providersWithCapability,
+  REASONING_EFFORTS,
   type ReasoningEffort,
   type RuntimeKind,
   registryModel,
   resolveDecisionModel,
   SUBSCRIPTION_DECISION_MODELS,
+  SUBSCRIPTION_WORKER_MODELS,
   vendorModeProvider,
   vendorOfProvider,
 } from './model-registry';
@@ -390,6 +392,7 @@ 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';
+export { createSerializedQueue, type SerializedQueue } from './serialized-queue';
 export {
   type DeliveredPart,
   layerPart,
@@ -408,12 +411,21 @@ export {
   type DispatchOptions,
   type FanResult,
   Thread,
+  type ThreadAgentStatus,
+  type ThreadCheckout,
   type ThreadConfig,
   type ThreadContext,
+  type ThreadDone,
+  type ThreadFork,
+  type ThreadLoop,
+  type ThreadLoopRound,
+  type ThreadMachine,
   type ThreadMeta,
   type ThreadName,
+  type ThreadPlan,
+  type ThreadPlanItem,
   type ThreadReference,
-  type ThreadSetup,
+  type ThreadSnooze,
   type ThreadSpawn,
   type ThreadStatus,
   threadTitle,
@@ -428,6 +440,7 @@ export {
   DEFAULT_COST_TABLE,
   estimateTokens,
   type ModelPricing,
+  modelPricing,
   TokenTracker,
   type TokenUsage,
   type UsageAttribution,

package/src/intervention.ts

@@ -1,3 +1,8 @@
+/**
+ * @atlas
+ * @kind service
+ * @partOf primitive:signals
+ */
 import { newId } from './id';
 import type { Signal, SignalBus } from './signal';
 import type { Span, Trace } from './trace';

package/src/messages.ts

@@ -1,3 +1,8 @@
+/**
+ * @atlas
+ * @kind helper
+ * @partOf primitive:nativeSessions
+ */
 import type {
   CompositionSnapshot,
   LayerInstanceState,

package/src/middleware.ts

@@ -1,3 +1,8 @@
+/**
+ * @atlas
+ * @kind service
+ * @partOf primitive:middleware
+ */
 import type { ExecutionResult } from './base-agent';
 import type { ContextStackView } from './context-stack';
 

package/src/model-registry.ts

@@ -1,3 +1,8 @@
+/**
+ * @atlas
+ * @kind registry
+ * @partOf primitive:modelRegistry
+ */
 /**
  * The model registry: the vocabulary of what models are worth using for, the
  * table of providers and models, and the lookups over it.
@@ -18,6 +23,7 @@ export type ProviderType =
   | 'gemini'
   | 'claude-code'
   | 'codex'
+  | 'muse'
   | 'xai'
   | 'typesafe'
   | 'custom';
@@ -82,7 +88,17 @@ export const MODEL_CAPABILITIES: readonly ModelCapability[] = [
 export type ProviderCredential = 'api-key' | 'subscription' | 'local';
 
 /** Effort levels hosts publish. A superset of CompletionOpts.thinking. */
-export type ReasoningEffort = 'none' | 'low' | 'medium' | 'high' | 'xhigh' | 'max' | 'ultra';
+export const REASONING_EFFORTS = [
+  'none',
+  'low',
+  'medium',
+  'high',
+  'xhigh',
+  'max',
+  'ultra',
+] as const;
+/** The one effort vocabulary: every effort setting and picker is a subset of it. */
+export type ReasoningEffort = (typeof REASONING_EFFORTS)[number];
 
 /**
  * How one model takes its reasoning controls. This is the map that replaced a
@@ -195,6 +211,13 @@ const MUSE_REASONING: ModelReasoning = {
   fallback: 'medium',
   outputField: 'max_completion_tokens',
 };
+/** Muse Code's catalogue (`<muse data>/model-catalog`): the CLI sends `effort` on each turn, high by default.
+ * `minimal` is offered too; Foundry's effort ladder starts at low. */
+const MUSE_CODE_REASONING: ModelReasoning = {
+  param: 'reasoning_effort',
+  efforts: ['low', 'medium', 'high', 'xhigh', 'max'],
+  fallback: 'high',
+};
 
 export interface FoundryProviderInfo {
   id: string;
@@ -236,6 +259,12 @@ export const SUBSCRIPTION_DECISION_MODELS = {
   claude: DECISION_MODEL,
   codex: 'gpt-5.6-luna',
 } as const;
+/** A subscription worker's main-thread model when a thread runs on a worker other than its project's default. */
+export const SUBSCRIPTION_WORKER_MODELS = {
+  'claude-code': 'fable',
+  codex: 'gpt-6-astra',
+  muse: 'muse-wonder-1.0',
+} 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[];
@@ -724,6 +753,55 @@ export const MODEL_REGISTRY: Record<string, FoundryProviderInfo> = {
       },
     ],
   },
+  muse: {
+    id: 'muse',
+    lab: 'meta',
+    type: 'muse',
+    label: 'Muse Code (Meta subscription)',
+    description:
+      "Native Muse Code harness (`muse serve`) using the user's own Muse login. Separate from Meta's pay-as-you-go Model API.",
+    credential: 'subscription',
+    // Off until the user turns on Meta's subscription mode: few machines have Muse Code signed in.
+    enabledByDefault: false,
+    models: [
+      // From the Muse Code 1.4.14 catalogue a Muse Code Everyday Usage login is served
+      // (`<muse data>/model-catalog`, 2026-11-01). The -contributor ids are hidden there and not listed.
+      {
+        id: 'muse-wonder-1.0',
+        label: 'Muse Wonder 1.0',
+        tier: 'powerful',
+        costTier: 'high',
+        contextWindow: 1_007_997,
+        maxOutputTokens: 128_000,
+        runtimeKind: 'native-harness',
+        capabilities: POWERFUL_REASONING,
+        reasoning: MUSE_CODE_REASONING,
+        notes: 'The Muse Code default.',
+      },
+      {
+        id: 'muse-spark-1.3',
+        label: 'Muse Spark 1.3',
+        tier: 'powerful',
+        costTier: 'high',
+        contextWindow: 1_007_997,
+        maxOutputTokens: 128_000,
+        runtimeKind: 'native-harness',
+        capabilities: POWERFUL_REASONING,
+        reasoning: MUSE_CODE_REASONING,
+      },
+      {
+        id: 'muse-spark-1.2',
+        label: 'Muse Spark 1.2',
+        tier: 'powerful',
+        costTier: 'high',
+        contextWindow: 1_007_997,
+        maxOutputTokens: 128_000,
+        runtimeKind: 'native-harness',
+        capabilities: POWERFUL_REASONING,
+        reasoning: { ...MUSE_CODE_REASONING, efforts: ['low', 'medium', 'high', 'xhigh'] },
+      },
+    ],
+  },
   meta: {
     id: 'meta',
     lab: 'meta',
@@ -1672,7 +1750,7 @@ export const MODEL_VENDORS: readonly ModelVendor[] = [
     id: 'meta',
     label: 'Meta (Muse)',
     lab: 'meta',
-    subscription: { comingSoon: true },
+    subscription: { provider: 'muse' },
     api: { provider: 'meta' },
   },
   {
@@ -1723,6 +1801,18 @@ export function modelOptionsByCapability(...capabilities: ModelCapability[]): Mo
   );
 }
 
+/**
+ * The efforts a registered model accepts, in order; undefined for a model the registry does not
+ * list (a local server's), which callers take as "not known, don't narrow".
+ */
+export function modelEfforts(
+  providerId: string,
+  modelId: string,
+): readonly ReasoningEffort[] | undefined {
+  const model = registryModel(providerId, modelId);
+  return model ? (model.reasoning?.efforts ?? []) : undefined;
+}
+
 export function registryModel(providerId: string, modelId: string): FoundryModelInfo | undefined {
   return MODEL_REGISTRY[providerId]?.models.find((model) => model.id === modelId);
 }

package/src/native-evidence.ts

@@ -1,3 +1,8 @@
+/**
+ * @atlas
+ * @kind transformer
+ * @partOf primitive:nativeSessions
+ */
 /** Public, owned projection. Raw protocol and reasoning are deliberately absent. */
 export interface NativeOwner {
   readonly threadId: string;
@@ -220,6 +225,8 @@ export interface NativeObservation {
   observe(evidence: NativeEvidence): void | Promise<void>;
   /** Receives the stop for this owner's registered admission, where the runtime acknowledges stops. */
   interruptible?(interrupt: NativeInterrupt): void;
+  /** Receives how to steer more input into this owner's registered admission, or why it can't be. */
+  steerable?(steer: NativeSteer): 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).
@@ -229,6 +236,17 @@ export interface NativeObservation {
 /** `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>;
+/** What became of a steer: taken into the running turn, sent but unconfirmed, or not delivered (with why). */
+export type NativeSteerOutcome =
+  | { readonly outcome: 'steered' | 'unknown' }
+  | { readonly outcome: 'ignored'; readonly reason: string };
+/**
+ * A running admission's steer (CORE-001): `push` adds text to that turn, where the runtime can steer.
+ * Where it can't, `push` is absent and `reason` says why, so the caller queues and says so.
+ */
+export type NativeSteer =
+  | { readonly push: (text: string) => Promise<NativeSteerOutcome> }
+  | { readonly push?: undefined; readonly reason: string };
 export function freezeEvidence<T>(value: T): T {
   const copy = structuredClone(value);
   const freeze = (v: unknown) => {

package/src/native-tools.ts

@@ -1,3 +1,8 @@
+/**
+ * @atlas
+ * @kind constant
+ * @partOf primitive:tools
+ */
 import type { Capability } from './capability';
 
 // Native harness tools by what they do: one list for Foundry's tool gate and work items, and for

package/src/retry.ts

@@ -1,3 +1,8 @@
+/**
+ * @atlas
+ * @kind middleware
+ * @partOf primitive:middleware
+ */
 import { CapabilityDeniedError } from './capability';
 import type { DispatchContext, Middleware, MiddlewareNext } from './middleware';
 import { BudgetExceededError } from './token-tracker';

package/src/router.ts

@@ -1,3 +1,8 @@
+/**
+ * @atlas
+ * @kind agent
+ * @partOf primitive:agents
+ */
 import type { AgentConfig } from './base-agent';
 import type { ContextStack } from './context-stack';
 import { Decider, type DeciderConfig, type Decision } from './decider';

package/src/scope.ts

@@ -1,3 +1,8 @@
+/**
+ * @atlas
+ * @kind type
+ * @partOf primitive:thread
+ */
 /**
  * Ownership scope — which thread and project an operation belongs to.
  *

package/src/serialized-queue.ts

@@ -0,0 +1,35 @@
+/**
+ * @atlas
+ * @kind utils
+ * @partOf primitive:concurrency
+ */
+// Copied from the template's packages/shared/src/utils/serializedQueue.ts.
+// Each run(fn) waits for the previous to settle before invoking fn; a failure
+// does not poison the chain. Errors still reject the caller's promise.
+
+export type SerializedQueue = {
+  run: <T>(fn: () => Promise<T>) => Promise<T>;
+  size: () => number;
+};
+
+export const createSerializedQueue = (): SerializedQueue => {
+  let tail: Promise<unknown> = Promise.resolve();
+  let pending = 0;
+
+  return {
+    run: <T>(fn: () => Promise<T>): Promise<T> => {
+      pending++;
+      const wrapped = async (): Promise<T> => {
+        try {
+          return await fn();
+        } finally {
+          pending--;
+        }
+      };
+      const next = tail.then(wrapped, wrapped);
+      tail = next;
+      return next;
+    },
+    size: () => pending,
+  };
+};

package/src/session-delivery.ts

@@ -1,3 +1,8 @@
+/**
+ * @atlas
+ * @kind helper
+ * @partOf primitive:nativeSessions
+ */
 import { computeHash } from './context-layer';
 import type { PromptBlock } from './context-stack';
 

package/src/signal.ts

@@ -1,3 +1,8 @@
+/**
+ * @atlas
+ * @kind service
+ * @partOf primitive:signals
+ */
 /**
  * Signal kinds — the Librarian's taxonomy.
  * Extensible via string union, not a closed enum.