@inixiative/foundry-core 0.2.0 → 0.4.0

package/src/native-evidence.ts

@@ -11,19 +11,32 @@ export interface NativeOwner {
 }
 /** Compare typed ownership fields, not serialization order or prompt text. */
 export function sameNativeOwner(a: NativeOwner | undefined, b: NativeOwner | undefined): boolean {
-  return !!a && !!b && (["threadId", "projectId", "generation", "messageId", "dispatchId", "reviewJobId", "providerSessionKey"] as const)
-    .every(key => a[key] === b[key]);
+  return (
+    !!a &&
+    !!b &&
+    (
+      [
+        'threadId',
+        'projectId',
+        'generation',
+        'messageId',
+        'dispatchId',
+        'reviewJobId',
+        'providerSessionKey',
+      ] as const
+    ).every((key) => a[key] === b[key])
+  );
 }
 export interface OwnedAdmissionInspection {
   readonly evidence: NativeEvidence;
   /** Physical call settlement is independent of a native terminal and local waiter. */
-  readonly call: "settled" | "pending" | "unknown";
-  readonly cleanup: "not-requested" | "pending" | "released" | "unknown";
-  readonly capacity: "settled" | "unknown";
+  readonly call: 'settled' | 'pending' | 'unknown';
+  readonly cleanup: 'not-requested' | 'pending' | 'released' | 'unknown';
+  readonly capacity: 'settled' | 'unknown';
 }
 export interface NativeEvidence {
   readonly schema: 1;
-  readonly executionMode?: "controlled-fixture";
+  readonly executionMode?: 'controlled-fixture';
   readonly owner?: NativeOwner;
   readonly admissionId?: string;
   readonly nativeSessionId?: string;
@@ -33,15 +46,22 @@ export interface NativeEvidence {
   readonly itemId?: string;
   readonly callId?: string;
   readonly rpcRequestId?: string | number;
-  readonly nativeOutcome: "unknown" | "completed" | "failed";
-  readonly localOutcome?: "pending" | "resolved" | "rejected";
-  readonly dispatch?: "not-dispatched" | "attempted";
-  readonly transportOutcome?: "open" | "failed" | "closed";
-  readonly rpcOutcome?: "pending" | "resolved" | "failed" | "unknown";
+  readonly nativeOutcome: 'unknown' | 'completed' | 'failed';
+  readonly localOutcome?: 'pending' | 'resolved' | 'rejected';
+  readonly dispatch?: 'not-dispatched' | 'attempted';
+  readonly transportOutcome?: 'open' | 'failed' | 'closed';
+  readonly rpcOutcome?: 'pending' | 'resolved' | 'failed' | 'unknown';
   readonly localFailure?: string;
   readonly localError?: string;
   readonly observedAt?: number;
-  readonly terminal?: Readonly<{ type: string; eventId?: string; turnId?: string; subtype?: string; reason?: string; apiErrorStatus?: number }>;
+  readonly terminal?: Readonly<{
+    type: string;
+    eventId?: string;
+    turnId?: string;
+    subtype?: string;
+    reason?: string;
+    apiErrorStatus?: number;
+  }>;
   readonly content?: string;
   readonly correlation?: string;
   readonly kind?: string;
@@ -60,27 +80,60 @@ export interface NativeEvidence {
   readonly toolOutputOmittedTypes?: readonly string[];
   readonly toolError?: boolean;
   readonly observationFailures?: number;
-  readonly configuration?: Readonly<{ requestedModel: string; observedModel?: string; requestedMaxTurns?: number | null;
-    engine?: "mcp" | "app-server"; transportMode?: "controlled-fixture"; requestedEffort?: string; observedEffort?: string | null;
-    history?: Readonly<{source:"thread/start"|"thread/resume";available:boolean;hasMore:boolean;turns:readonly Readonly<{id:string;status:string}>[]}>;
-    turnBudgetEnforcement: "launch-option" | "unavailable"; tokenBudget: "unavailable"; effortBudget: "unavailable" }>;
+  readonly configuration?: Readonly<{
+    requestedModel: string;
+    observedModel?: string;
+    requestedMaxTurns?: number | null;
+    engine?: 'mcp' | 'app-server';
+    transportMode?: 'controlled-fixture';
+    requestedEffort?: string;
+    observedEffort?: string | null;
+    history?: Readonly<{
+      source: 'thread/start' | 'thread/resume';
+      available: boolean;
+      hasMore: boolean;
+      turns: readonly Readonly<{ id: string; status: string }>[];
+    }>;
+    turnBudgetEnforcement: 'launch-option' | 'unavailable';
+    tokenBudget: 'unavailable';
+    effortBudget: 'unavailable';
+  }>;
   readonly text?: string;
   /** Public text form only; reasoning is never projected. Missing phase is not a final-answer acknowledgment. */
-  readonly textKind?: "delta" | "snapshot";
-  readonly textPhase?: "commentary" | "final_answer";
+  readonly textKind?: 'delta' | 'snapshot';
+  readonly textPhase?: 'commentary' | 'final_answer';
   /** Safe setup/status evidence, never launch paths or config values. */
-  readonly runtimeStatus?: Readonly<{ type: string; status?: string; reason?: string; server?: string; tools?: readonly string[] }>;
-  readonly bridge?: { readonly id: string; readonly configurationHash: string; readonly toolPolicy?: NativeToolPolicy; readonly tools: readonly NativeToolEvidence[] };
+  readonly runtimeStatus?: Readonly<{
+    type: string;
+    status?: string;
+    reason?: string;
+    server?: string;
+    tools?: readonly string[];
+  }>;
+  readonly bridge?: {
+    readonly id: string;
+    readonly configurationHash: string;
+    readonly toolPolicy?: NativeToolPolicy;
+    readonly tools: readonly NativeToolEvidence[];
+  };
 }
 export interface NativeToolRecord {
   readonly id: string;
   readonly bridgeId: string;
   readonly operation: string;
-  readonly owner: { readonly threadId: string; readonly projectId?: string; readonly generation: string };
-  readonly association: { readonly kind: "registered-admission-window" | "unassociated"; readonly admissionId?: string; readonly owner?: NativeOwner };
+  readonly owner: {
+    readonly threadId: string;
+    readonly projectId?: string;
+    readonly generation: string;
+  };
+  readonly association: {
+    readonly kind: 'registered-admission-window' | 'unassociated';
+    readonly admissionId?: string;
+    readonly owner?: NativeOwner;
+  };
   readonly sdkRequestId?: string | number;
   readonly sdkSessionId?: string;
-  readonly nativeCorrelation: "unknown";
+  readonly nativeCorrelation: 'unknown';
   readonly startedAt: number;
   readonly finishedAt: number;
   readonly arguments: Readonly<Record<string, unknown>>;
@@ -91,8 +144,8 @@ export interface NativeToolRecord {
 }
 export interface NativeToolEvidence {
   readonly record: NativeToolRecord;
-  readonly persistence: "pending" | "committed" | "failed";
-  readonly publication: "pending" | "published" | "reconciliation-needed";
+  readonly persistence: 'pending' | 'committed' | 'failed';
+  readonly publication: 'pending' | 'published' | 'reconciliation-needed';
   readonly error?: string;
 }
 /** Process lifetime grant. Data/functions never become part of a provider prompt. */
@@ -105,7 +158,11 @@ export interface NativeBridgeSource {
 export interface NativeBridgeLease {
   readonly id: string;
   readonly name: string;
-  readonly owner: { readonly threadId: string; readonly projectId?: string; readonly generation: string };
+  readonly owner: {
+    readonly threadId: string;
+    readonly projectId?: string;
+    readonly generation: string;
+  };
   readonly configurationHash: string;
   readonly toolPolicy?: NativeToolPolicy;
   /** Private, empty native cwd owned by a restricted fixture lease. */
@@ -115,12 +172,17 @@ export interface NativeBridgeLease {
   register(evidence: NativeEvidence): void;
   observe(evidence: NativeEvidence): void;
   evidence(admissionId?: string): readonly NativeToolEvidence[];
-  status?(): Readonly<{ closed: boolean; pendingCleanups: number; cleanupFailures: number; evictedRecords: number }>;
+  status?(): Readonly<{
+    closed: boolean;
+    pendingCleanups: number;
+    cleanupFailures: number;
+    evictedRecords: number;
+  }>;
   close(): Promise<void>;
 }
 /** Immutable policy identity; contains no credentials, launch paths or tool input. */
 export interface NativeToolPolicy {
-  readonly version: "isolated-fixture-v1";
+  readonly version: 'isolated-fixture-v1';
   readonly digest: string;
 }
 export interface NativeObservation {
@@ -135,6 +197,38 @@ export interface NativeObservation {
 }
 export function freezeEvidence<T>(value: T): T {
   const copy = structuredClone(value);
-  const freeze = (v: unknown) => { if (v && typeof v === "object" && !Object.isFrozen(v)) { for (const nested of Object.values(v)) freeze(nested); Object.freeze(v); } };
-  freeze(copy); return copy;
+  const freeze = (v: unknown) => {
+    if (v && typeof v === 'object' && !Object.isFrozen(v)) {
+      for (const nested of Object.values(v)) freeze(nested);
+      Object.freeze(v);
+    }
+  };
+  freeze(copy);
+  return copy;
+}
+/** The model and effort a call ran on. */
+export interface ServedModel {
+  readonly model: string;
+  readonly effort?: string;
+}
+/** What a native configuration says ran: the engine's acknowledgment over the request. */
+export function configuredModel(
+  configuration: NativeEvidence['configuration'] | undefined,
+): ServedModel | undefined {
+  if (!configuration) return undefined;
+  const model = configuration.observedModel ?? configuration.requestedModel;
+  const effort =
+    configuration.observedEffort === null
+      ? undefined
+      : (configuration.observedEffort ?? configuration.requestedEffort);
+  return model ? { model, ...(effort ? { effort } : {}) } : undefined;
+}
+/** What served a completion: its native configuration, else the model the provider reports. */
+export function servedModel(
+  result: Pick<import('./types').CompletionResult, 'model' | 'native'>,
+): ServedModel | undefined {
+  return (
+    configuredModel(result.native?.configuration) ??
+    (result.model ? { model: result.model } : undefined)
+  );
 }

package/src/permission-middleware.ts

@@ -1,12 +1,8 @@
-import type { Middleware, DispatchContext, MiddlewareNext } from "./middleware";
-import {
-  CapabilityGate,
-  CapabilityDeniedError,
-  type Capability,
-} from "./capability";
+import { type Capability, CapabilityDeniedError, type CapabilityGate } from './capability';
+import type { DispatchContext, Middleware, MiddlewareNext } from './middleware';
 
 export interface PermissionCheckResult {
-  action: "allow" | "deny" | "ask";
+  action: 'allow' | 'deny' | 'ask';
   /** Optional modified payload (like Claude Code's updatedInput). */
   modifiedPayload?: unknown;
   /** Reason for denial. */
@@ -40,12 +36,7 @@ export interface PermissionMiddlewareConfig {
  * Records permission decisions in ctx.annotations.
  */
 export function permissionMiddleware(config: PermissionMiddlewareConfig): Middleware {
-  const {
-    gate,
-    threadId,
-    defaultCapability = "llm:call",
-    checks,
-  } = config;
+  const { gate, threadId, defaultCapability = 'llm:call', checks } = config;
 
   return async (ctx: DispatchContext, next: MiddlewareNext) => {
     // Check default capability via gate
@@ -55,14 +46,14 @@ export function permissionMiddleware(config: PermissionMiddlewareConfig): Middle
       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");
+    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;
+    ctx.annotations['permission:approved'] = true;
+    ctx.annotations['permission:by'] = resolution.by;
 
     // Run custom checks
     if (checks) {
@@ -71,18 +62,15 @@ export function permissionMiddleware(config: PermissionMiddlewareConfig): Middle
 
         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.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;
+          ctx.annotations['permission:modifiedPayload'] = result.modifiedPayload;
         }
       }
     }

package/src/retry.ts

@@ -1,6 +1,6 @@
-import type { Middleware, DispatchContext, MiddlewareNext } from "./middleware";
-import { CapabilityDeniedError } from "./capability";
-import { BudgetExceededError } from "./token-tracker";
+import { CapabilityDeniedError } from './capability';
+import type { DispatchContext, Middleware, MiddlewareNext } from './middleware';
+import { BudgetExceededError } from './token-tracker';
 
 export interface RetryConfig {
   /** Maximum retry attempts. Default: 3. */
@@ -64,7 +64,7 @@ export function retryMiddleware(config: RetryConfig = {}): Middleware {
         const elapsed = Date.now() - startTime;
         if (elapsed >= giveUpAfterMs) break;
 
-        let delay = initialDelayMs * Math.pow(backoffFactor, attempt);
+        let delay = initialDelayMs * backoffFactor ** attempt;
         delay = Math.min(delay, maxDelayMs);
 
         if (jitter) {
@@ -79,8 +79,8 @@ export function retryMiddleware(config: RetryConfig = {}): Middleware {
         }
 
         onRetry?.(attempt + 1, error, delay);
-        ctx.annotations["retry:attempt"] = attempt + 1;
-        ctx.annotations["retry:lastError"] = String(error);
+        ctx.annotations['retry:attempt'] = attempt + 1;
+        ctx.annotations['retry:lastError'] = String(error);
 
         await sleep(delay);
       }

package/src/router.ts

@@ -1,7 +1,7 @@
-import { Decider, type DeciderConfig, type Decision } from "./decider";
-import type { AgentConfig } from "./base-agent";
-import type { ContextStack } from "./context-stack";
-import type { ExecuteMeta } from "./executor";
+import type { AgentConfig } from './base-agent';
+import type { ContextStack } from './context-stack';
+import { Decider, type DeciderConfig, type Decision } from './decider';
+import type { ExecuteMeta } from './executor';
 
 /**
  * A routing decision — "where should this go?"
@@ -16,7 +16,7 @@ export interface Route {
 export type RouteHandler<TPayload> = (
   context: string,
   payload: TPayload,
-  meta?: ExecuteMeta
+  meta?: ExecuteMeta,
 ) => Promise<Decision<Route>>;
 
 export interface RouterConfig<TPayload = unknown> extends AgentConfig {

package/src/signal.ts

@@ -3,12 +3,13 @@
  * Extensible via string union, not a closed enum.
  */
 export type SignalKind =
-  | "correction"
-  | "convention"
-  | "taste"
-  | "ci_rule"
-  | "adr"
-  | "security"
+  | 'correction'
+  | 'convention'
+  | 'taste'
+  | 'ci_rule'
+  | 'adr'
+  | 'security'
+  | 'guard_finding'
   | (string & {});
 
 /**
@@ -89,7 +90,10 @@ export class SignalBus {
       try {
         await handler(signal);
       } catch (err) {
-        console.warn(`[SignalBus] handler error for signal "${signal.kind}":`, (err as Error).message ?? err);
+        console.warn(
+          `[SignalBus] handler error for signal "${signal.kind}":`,
+          (err as Error).message ?? err,
+        );
       }
     }
 
@@ -97,16 +101,17 @@ export class SignalBus {
       try {
         await handler(signal);
       } catch (err) {
-        console.warn(`[SignalBus] global handler error for signal "${signal.kind}":`, (err as Error).message ?? err);
+        console.warn(
+          `[SignalBus] global handler error for signal "${signal.kind}":`,
+          (err as Error).message ?? err,
+        );
       }
     }
   }
 
   /** Get recent signals, optionally filtered by kind. */
   recent(kind?: SignalKind, limit: number = 50): ReadonlyArray<Signal> {
-    const filtered = kind
-      ? this._history.filter((s) => s.kind === kind)
-      : this._history;
+    const filtered = kind ? this._history.filter((s) => s.kind === kind) : this._history;
     return filtered.slice(-limit);
   }