@wibly/internal-manifest 0.1.1 → 0.1.2

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # `@wibly/internal-manifest` — Changelog
 
+## 0.1.2 — 2026-06-08
+
+### Added
+
+- `workflow.abortPhaseId` (optional) — the phase a `host.abort` jumps
+  to. When omitted the Runtime aborts to the last declared phase.
+  Validated against the declared phase ids (`unknown_abort_phase`).
+
 ## 0.1.1 — 2026-05-30
 
 Initial public npm release. Internal runtime dependency of `@wibly/sdk` and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wibly/internal-manifest",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Wibly @wibly/internal-manifest",
   "type": "module",
   "main": "./src/index.ts",
@@ -17,8 +17,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@wibly/internal-protocol": "0.1.1",
-    "@wibly/internal-shared": "0.1.1",
+    "@wibly/internal-protocol": "0.1.2",
+    "@wibly/internal-shared": "0.1.2",
     "zod": "^3.25.76"
   },
   "peerDependencies": {}

package/src/fixtures.ts

@@ -146,18 +146,22 @@ export const validManifestFixture: Manifest = {
   ],
   promptSlots: {
     experienceSystem: 'You are running Hello World, a tiny test Experience.',
-    callTypes: {
-      host_open_phase: 'Open the next phase with one short sentence.',
+    callTemplates: {
+      host_open_phase: {
+        prompt: 'Open the next phase with one short sentence.',
+        qualityTier: 'standard',
+        fallbackResponse: 'Welcome — let us begin.',
+      },
       host_recap: {
-        template: 'Recap the round for {playerCount} players.',
-        vars: ['playerCount'],
+        prompt: {
+          template: 'Recap the round for {playerCount} players.',
+          vars: ['playerCount'],
+        },
+        qualityTier: 'standard',
+        fallbackResponse: 'Thanks for playing.',
       },
     },
   },
-  fallbackResponses: {
-    host_open_phase: 'Welcome — let us begin.',
-    host_recap: 'Thanks for playing.',
-  },
   widgetDependencies: ['Lobby', 'GuessInput', 'Leaderboard'],
   contentRating: {
     tier: 'none',
@@ -205,12 +209,16 @@ export const cloneFixture = (): Manifest =>
  */
 export const cloneFixtureWithInferenceSideEffect = (): Manifest => {
   const fixture = cloneFixture();
+  fixture.promptSlots.callTemplates.host_judge = {
+    prompt: 'Judge submissions.',
+    qualityTier: 'standard',
+    fallbackResponse: 'tie',
+  };
   patchPhase(fixture, 'guess', {
     sideEffects: [
       {
         kind: 'inference',
-        callKind: 'host_judge',
-        qualityTier: 'standard',
+        templateId: 'host_judge',
         targetPath: '/session/inference/host_judge',
       },
     ],

package/src/index.ts

@@ -51,13 +51,12 @@ export {
   AwardCriterionSchema,
   AwardDefinitionSchema,
   BundleContextSlotsSchema,
-  CallKindSchema,
+  CallTemplateSchema,
   ConcurrentOpportunitySchema,
   ContentRatingAudienceSchema,
   ContentRatingFloorSchema,
   ContentRatingSchema,
   ExperienceContentRatingTierSchema,
-  FallbackResponsesSchema,
   GameplayImageSchema,
   GameplayVideoSchema,
   InferenceEnvelopeSchema,
@@ -74,6 +73,9 @@ export {
   PromptSlotsSchema,
   PromptSlotValueSchema,
   QualityTierSchema,
+  PLATFORM_CLASSIFY_TEMPLATE_ID,
+  getCallTemplate,
+  isPlatformClassifyTemplate,
   ScoringAggregatorSchema,
   ScoringDimensionSchema,
   ScoringSchema,
@@ -82,13 +84,12 @@ export {
   type AwardCriterion,
   type AwardDefinition,
   type BundleContextSlots,
-  type CallKind,
+  type CallTemplate,
   type ConcurrentOpportunity,
   type ContentRating,
   type ContentRatingAudience,
   type ContentRatingFloor,
   type ExperienceContentRatingTier,
-  type FallbackResponses,
   type GameplayImage,
   type GameplayVideo,
   type InferenceEnvelope,
@@ -109,10 +110,24 @@ export {
   type Scoring,
   type ScoringAggregator,
   type ScoringDimension,
+  type SessionSettings,
   type StateSchema,
   type Workflow,
 } from './manifest.js';
 
+export {
+  resolveSessionSettings,
+  SessionSettingBooleanDefinitionSchema,
+  SessionSettingDefinitionSchema,
+  SessionSettingEnumDefinitionSchema,
+  SessionSettingNumberDefinitionSchema,
+  SessionSettingsSchema,
+  validateSessionSettingsOverrides,
+  type ResolvedSessionSettings,
+  type SessionSettingDefinition,
+  type SessionSettingsValidationResult,
+} from './session-settings.js';
+
 export {
   validateManifest,
   type ValidationError,

package/src/manifest.test.ts

@@ -138,13 +138,18 @@ describe('PromptSlotValueSchema / PromptSlotsSchema', () => {
     ).toBe(false);
   });
 
-  it('rejects a callTypes key outside the known callKind set', () => {
+  it('accepts callTemplates with free-form ids', () => {
     expect(
       PromptSlotsSchema.safeParse({
         experienceSystem: 'sys',
-        callTypes: { unknown_kind: 'hello' },
+        callTemplates: {
+          my_custom_template: {
+            prompt: 'hello',
+            qualityTier: 'standard',
+          },
+        },
       }).success,
-    ).toBe(false);
+    ).toBe(true);
   });
 });
 
@@ -266,7 +271,6 @@ describe('ManifestSchema — required fields', () => {
     'scoring',
     'lifecyclePolicies',
     'promptSlots',
-    'fallbackResponses',
     'widgetDependencies',
     'contentRating',
     'portalMetadata',

package/src/manifest.ts

@@ -7,8 +7,7 @@
  * Session:
  *
  * - identity & ownership (`id`, `version`, `tenant`, `creator`),
- * - safety / cost shape (`inferenceEnvelope`, `contentRating`,
- *   `fallbackResponses`),
+ * - safety / cost shape (`inferenceEnvelope`, `contentRating`),
  * - workflow (`workflow.phases`, `concurrentOpportunities`,
  *   `lifecyclePolicies`),
  * - state shape (`stateSchema`),
@@ -32,13 +31,17 @@
 import { z } from 'zod';
 
 import {
-  CallKindSchema,
   CollectionRuleSchema,
   InputSetSchema,
   PhaseSchema,
 } from './phase.js';
+import { SessionSettingsSchema } from './session-settings.js';
 
-export { CallKindSchema };
+/** Platform-internal template id for the safety classifier (not in manifest). */
+export const PLATFORM_CLASSIFY_TEMPLATE_ID = 'classify';
+
+export const isPlatformClassifyTemplate = (templateId: string): boolean =>
+  templateId === PLATFORM_CLASSIFY_TEMPLATE_ID;
 
 // -----------------------------------------------------------------------------
 // JSON value (used for state-schema slices and scoring payloads)
@@ -194,6 +197,14 @@ export const StateSchemaSchema = z.object({
 export const WorkflowSchema = z.object({
   initialPhase: z.string().min(1),
   phases: z.array(PhaseSchema).min(1),
+  /**
+   * Phase the platform jumps to on `host.abort` (a universal mid-game
+   * abort, handled by the Runtime — games need NO per-phase abort wiring).
+   * Optional: when omitted, the Runtime aborts to the LAST declared phase
+   * (conventionally the final/results screen). Set this only to override
+   * that default.
+   */
+  abortPhaseId: z.string().min(1).optional(),
 });
 
 // -----------------------------------------------------------------------------
@@ -360,43 +371,27 @@ export const PromptSlotValueSchema = z.union([
 ]);
 
 /**
- * The known set of `callKind`s the prompt composer (chunk B4) maps to
- * the eight-layer prompt. Listed in
- * `docs/conventions/prompt-composition.md`. Every callKind that appears
- * here MUST appear in that document; new callKinds land in the chunk
- * that introduces them with the doc updated in the same commit.
- *
- * Defined in `phase.ts` (re-exported above) so the chunk-B8c
- * `WorkflowSideEffect.inference.callKind` schema can reference it
- * without a circular import.
+ * One creator-defined LLM call template. Game code invokes by
+ * `templateId` (the record key); Studio edits prompt, schema, tier,
+ * and fallback copy without redeploying bundles.
  */
+export const CallTemplateSchema = z.object({
+  prompt: PromptSlotValueSchema,
+  returnSchema: JsonValueSchema.optional(),
+  qualityTier: QualityTierSchema.default('standard'),
+  fallbackResponse: z.string().min(1).optional(),
+});
 
 /**
  * Manifest-supplied prompt content. `experienceSystem` is the layer-3
- * Experience system message; `callTypes` keys per `callKind` populate
- * layer 4; `outputSchemas` populates layer 7 with a JSON-shaped schema
- * the Gateway renders. Per the prompt-composition doc, the platform
- * supplies the structural layers (1, 4-structural, 5, 6, 8) and the
- * Persona Service supplies layer 2; everything below is the manifest's
- * contribution.
+ * Experience system message; `callTemplates` supplies layer 4 (call
+ * instructions) and optional layer-7 return schemas per template id.
  */
 export const PromptSlotsSchema = z.object({
   experienceSystem: PromptSlotValueSchema,
-  callTypes: z.record(CallKindSchema, PromptSlotValueSchema),
-  outputSchemas: z.record(CallKindSchema, JsonValueSchema).optional(),
+  callTemplates: z.record(z.string().min(1), CallTemplateSchema),
 });
 
-// -----------------------------------------------------------------------------
-// Fallback responses
-// -----------------------------------------------------------------------------
-
-/**
- * Pre-written copy the Runtime emits when an inference call fails or
- * the safety pipeline blocks the model output. Keyed per `callKind` so
- * a host_judge fallback is distinct from a host_recap fallback.
- */
-export const FallbackResponsesSchema = z.record(CallKindSchema, z.string().min(1));
-
 // -----------------------------------------------------------------------------
 // Content rating
 // -----------------------------------------------------------------------------
@@ -554,10 +549,14 @@ export const ManifestSchema = z.object({
   scoring: ScoringSchema,
   lifecyclePolicies: z.array(LifecyclePolicySchema),
   promptSlots: PromptSlotsSchema,
-  fallbackResponses: FallbackResponsesSchema,
   widgetDependencies: z.array(z.string().min(1)),
   contentRating: ContentRatingSchema,
   portalMetadata: PortalMetadataSchema,
+  /**
+   * Host-configurable knobs chosen at session provision (Portal launch
+   * dialog). Defaults are applied when the host omits a value.
+   */
+  sessionSettings: SessionSettingsSchema.optional(),
   /** Reserved for Phase 2; current Runtime ignores these. */
   bundleCompatible: z.boolean().default(false).optional(),
   /** Reserved for Phase 2; current Runtime ignores these. */
@@ -590,9 +589,14 @@ export type LifecycleSituation = z.infer<typeof LifecycleSituationSchema>;
 export type LifecycleAction = z.infer<typeof LifecycleActionSchema>;
 export type LifecyclePolicy = z.infer<typeof LifecyclePolicySchema>;
 export type PromptSlotValue = z.infer<typeof PromptSlotValueSchema>;
-export type CallKind = z.infer<typeof CallKindSchema>;
+export type CallTemplate = z.infer<typeof CallTemplateSchema>;
 export type PromptSlots = z.infer<typeof PromptSlotsSchema>;
-export type FallbackResponses = z.infer<typeof FallbackResponsesSchema>;
+
+export const getCallTemplate = (
+  manifest: Manifest,
+  templateId: string,
+): CallTemplate | undefined =>
+  manifest.promptSlots.callTemplates[templateId];
 export type ContentRatingFloor = z.infer<typeof ContentRatingFloorSchema>;
 export type ContentRatingAudience = z.infer<typeof ContentRatingAudienceSchema>;
 export type ExperienceContentRatingTier = z.infer<
@@ -603,5 +607,6 @@ export type OccasionTag = z.infer<typeof OccasionTagSchema>;
 export type GameplayImage = z.infer<typeof GameplayImageSchema>;
 export type GameplayVideo = z.infer<typeof GameplayVideoSchema>;
 export type PortalMetadata = z.infer<typeof PortalMetadataSchema>;
+export type SessionSettings = z.infer<typeof SessionSettingsSchema>;
 export type BundleContextSlots = z.infer<typeof BundleContextSlotsSchema>;
 export type Manifest = z.infer<typeof ManifestSchema>;

package/src/phase.test.ts

@@ -49,6 +49,10 @@ describe('CollectionRuleSchema', () => {
     expect(CollectionRuleSchema.safeParse({ kind: 'all_respond' }).success).toBe(
       true,
     );
+    expect(
+      CollectionRuleSchema.safeParse({ kind: 'all_respond_or_timeout', ms: 45_000 })
+        .success,
+    ).toBe(true);
     expect(
       CollectionRuleSchema.safeParse({ kind: 'first_respond', count: 3 })
         .success,
@@ -59,6 +63,13 @@ describe('CollectionRuleSchema', () => {
     expect(CollectionRuleSchema.safeParse({ kind: 'manual' }).success).toBe(
       true,
     );
+    expect(
+      CollectionRuleSchema.safeParse({
+        kind: 'after_tts_completes',
+        timeout: 60_000,
+        buffer: 2_000,
+      }).success,
+    ).toBe(true);
   });
 
   it('rejects a zero-ms timeout (would deadlock the Runtime)', () => {
@@ -143,7 +154,7 @@ describe('PhaseSchema', () => {
       ...baseline,
       sideEffects: [
         { kind: 'state_write', patches: [{ op: 'replace', path: '/x', value: 1 }] },
-        { kind: 'inference', callKind: 'host_judge' },
+        { kind: 'inference', templateId: 'host_judge' },
       ],
     });
     expect(result.success).toBe(true);
@@ -159,6 +170,26 @@ describe('PhaseSchema', () => {
     });
     expect(result.success).toBe(false);
   });
+
+  it('accepts optional leadInSpeech variants', () => {
+    const result = PhaseSchema.safeParse({
+      ...baseline,
+      leadInSpeech: ['Welcome.', 'Let us begin.'],
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.leadInSpeech).toEqual([
+        'Welcome.',
+        'Let us begin.',
+      ]);
+    }
+  });
+
+  it('rejects empty leadInSpeech lines', () => {
+    expect(
+      PhaseSchema.safeParse({ ...baseline, leadInSpeech: [''] }).success,
+    ).toBe(false);
+  });
 });
 
 describe('WorkflowSideEffectSchema (chunk B8c)', () => {
@@ -181,25 +212,24 @@ describe('WorkflowSideEffectSchema (chunk B8c)', () => {
   it('accepts an inference effect with a targetPath JSON-Pointer', () => {
     const result = WorkflowSideEffectSchema.safeParse({
       kind: 'inference',
-      callKind: 'host_judge',
-      qualityTier: 'standard',
+      templateId: 'host_judge',
       targetPath: '/session/inference/host_judge',
     });
     expect(result.success).toBe(true);
   });
 
-  it('rejects an inference effect whose callKind is outside the enum', () => {
+  it('accepts any non-empty templateId string', () => {
     const result = WorkflowSideEffectSchema.safeParse({
       kind: 'inference',
-      callKind: 'totally_made_up',
+      templateId: 'totally_made_up',
     });
-    expect(result.success).toBe(false);
+    expect(result.success).toBe(true);
   });
 
   it('rejects an inference effect with a malformed targetPath', () => {
     const result = WorkflowSideEffectSchema.safeParse({
       kind: 'inference',
-      callKind: 'host_judge',
+      templateId: 'host_judge',
       targetPath: 'not-a-pointer',
     });
     expect(result.success).toBe(false);

package/src/phase.ts

@@ -70,6 +70,15 @@ export const InputSetSchema = z.object({
  */
 export const CollectionRuleSchema = z.discriminatedUnion('kind', [
   z.object({ kind: z.literal('all_respond') }),
+  z.object({
+    kind: z.literal('all_respond_or_timeout'),
+    ms: z.number().int().positive(),
+  }),
+  z.object({
+    kind: z.literal('after_tts_completes'),
+    timeout: z.number().int().positive(),
+    buffer: z.number().int().nonnegative(),
+  }),
   z.object({
     kind: z.literal('first_respond'),
     count: z.number().int().positive(),
@@ -97,35 +106,6 @@ export const TransitionSchema = z.object({
 // Phase side-effect declarations (chunk B8c)
 // -----------------------------------------------------------------------------
 
-/**
- * Quality-tier enum lifted here (chunk B8c) so the side-effect schema
- * can carry an optional `qualityTier` without requiring a circular
- * import. Mirrors `QualityTierSchema` re-exported from `manifest.ts`.
- */
-const PhaseSideEffectQualityTierSchema = z.enum([
-  'fast',
-  'standard',
-  'premium',
-  'creative',
-]);
-
-/**
- * Known `callKind` set lifted here for the same reason as
- * {@link PhaseSideEffectQualityTierSchema}. Kept exactly in lock-step
- * with `CallKindSchema` in `manifest.ts`; `manifest.ts` imports this
- * symbol so they cannot drift.
- */
-export const CallKindSchema = z.enum([
-  'host_open_phase',
-  'host_judge',
-  'host_resolve',
-  'host_recap',
-  'judge_funniness',
-  'narrate_event',
-  'classify',
-  'compose_clue',
-]);
-
 /**
  * RFC 6901 JSON-Pointer validator. Accepts the empty pointer `""`
  * (root) and any pointer starting with `/`. We do NOT enforce
@@ -161,17 +141,16 @@ export const StateWriteSideEffectSchema = z.object({
 });
 
 /**
- * `inference` side effect — dispatch a Gateway call. `callKind` keys
- * the prompt-composition layer 4 entry; `slots` carries per-call
- * variables for template interpolation. `targetPath` is an
- * RFC 6901 JSON-Pointer the Runtime writes the inference output to
- * once the Gateway returns (default at handler time:
- * `/session/inference/<callKind>`).
+ * `inference` side effect — dispatch a Gateway call. `templateId`
+ * keys a manifest `callTemplates` entry; `slots` carries per-call
+ * variables for template interpolation. Quality tier and return schema
+ * come from the template definition. `targetPath` is an RFC 6901
+ * JSON-Pointer the Runtime writes the inference output to once the
+ * Gateway returns (default: `/session/inference/<templateId>`).
  */
 export const InferenceSideEffectSchema = z.object({
   kind: z.literal('inference'),
-  callKind: CallKindSchema,
-  qualityTier: PhaseSideEffectQualityTierSchema.optional(),
+  templateId: z.string().min(1),
   slots: z.record(z.unknown()).optional(),
   targetPath: JsonPointerSchema.optional(),
 });
@@ -254,7 +233,16 @@ export type WorkflowSideEffect = z.infer<typeof WorkflowSideEffectSchema>;
  *     fires the sandbox `onRoundEnd` hook on phase EXIT (before
  *     the swap). Used by multi-round Experiences (Rashomon) to
  *     trigger end-of-round bookkeeping in the bundle.
+ *   - `leadInSpeech?: string[]` — optional static host-voice lines
+ *     spoken on phase enter. Omitted or empty skips platform TTS.
+ *     When multiple lines are declared the runtime picks one at
+ *     random (deterministic per transition). The number of variants
+ *     is unbounded — Experiences may ship large pools of filler lines
+ *     to keep the host fresh across many rounds. Richer (dynamic)
+ *     lead-ins still belong in the sandbox `onPhaseEnter` hook.
  */
+const LEAD_IN_SPEECH_MAX_CHARS = 500;
+
 export const PhaseSchema = z.lazy(() =>
   z.object({
     id: z.string().min(1),
@@ -265,6 +253,9 @@ export const PhaseSchema = z.lazy(() =>
     subPhases: z.record(z.string().min(1), PhaseSchema).optional(),
     computeScoreOnEnter: z.boolean().optional(),
     endsRound: z.boolean().optional(),
+    leadInSpeech: z
+      .array(z.string().min(1).max(LEAD_IN_SPEECH_MAX_CHARS))
+      .optional(),
   }),
 ) as z.ZodType<ManifestPhase>;
 
@@ -301,4 +292,5 @@ export type ManifestPhase = {
   readonly subPhases?: Readonly<Record<string, ManifestPhase>>;
   readonly computeScoreOnEnter?: boolean;
   readonly endsRound?: boolean;
+  readonly leadInSpeech?: readonly string[];
 };

package/src/session-settings.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  resolveSessionSettings,
+  validateSessionSettingsOverrides,
+} from './session-settings.js';
+
+describe('session-settings', () => {
+  const definitions = [
+    {
+      key: 'totalRounds',
+      type: 'number' as const,
+      label: 'Rounds',
+      min: 3,
+      max: 12,
+      default: 8,
+    },
+    {
+      key: 'hardMode',
+      type: 'boolean' as const,
+      label: 'Hard mode',
+      default: false,
+    },
+  ];
+
+  it('resolves defaults when overrides are omitted', () => {
+    expect(resolveSessionSettings(definitions, undefined)).toEqual({
+      totalRounds: 8,
+      hardMode: false,
+    });
+  });
+
+  it('validates in-range overrides', () => {
+    const result = validateSessionSettingsOverrides(definitions, {
+      totalRounds: 10,
+      hardMode: true,
+    });
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.settings).toEqual({ totalRounds: 10, hardMode: true });
+    }
+  });
+
+  it('rejects unknown keys', () => {
+    const result = validateSessionSettingsOverrides(definitions, {
+      mystery: true,
+    });
+    expect(result.ok).toBe(false);
+  });
+});

package/src/session-settings.ts

@@ -0,0 +1,190 @@
+/**
+ * Host-configurable session settings declared in the Experience manifest.
+ *
+ * Settings are authored in Studio, chosen at provision time (Portal launch
+ * dialog), validated against manifest definitions, and written to
+ * `/session/settings` before sandbox hooks run.
+ */
+
+import { z } from 'zod';
+
+import type { JsonValue } from './manifest.js';
+
+const SettingKeySchema = z
+  .string()
+  .regex(/^[a-z][a-zA-Z0-9_]*$/, 'setting key must be camelCase');
+
+const SessionSettingDefinitionBaseSchema = z.object({
+  key: SettingKeySchema,
+  label: z.string().min(1),
+  description: z.string().optional(),
+});
+
+export const SessionSettingNumberDefinitionSchema =
+  SessionSettingDefinitionBaseSchema.extend({
+    type: z.literal('number'),
+    default: z.number(),
+    min: z.number().optional(),
+    max: z.number().optional(),
+    step: z.number().positive().optional(),
+  });
+
+export const SessionSettingBooleanDefinitionSchema =
+  SessionSettingDefinitionBaseSchema.extend({
+    type: z.literal('boolean'),
+    default: z.boolean(),
+  });
+
+export const SessionSettingEnumDefinitionSchema =
+  SessionSettingDefinitionBaseSchema.extend({
+    type: z.literal('enum'),
+    options: z
+      .array(
+        z.object({
+          value: z.string().min(1),
+          label: z.string().min(1),
+        }),
+      )
+      .min(1),
+    default: z.string().min(1),
+  });
+
+export const SessionSettingDefinitionSchema = z.discriminatedUnion('type', [
+  SessionSettingNumberDefinitionSchema,
+  SessionSettingBooleanDefinitionSchema,
+  SessionSettingEnumDefinitionSchema,
+]);
+
+export const SessionSettingsSchema = z.object({
+  definitions: z.array(SessionSettingDefinitionSchema).default([]),
+});
+
+export type SessionSettingDefinition = z.infer<
+  typeof SessionSettingDefinitionSchema
+>;
+export type SessionSettings = z.infer<typeof SessionSettingsSchema>;
+export type ResolvedSessionSettings = Readonly<Record<string, JsonValue>>;
+
+const definitionByKey = (
+  definitions: readonly SessionSettingDefinition[],
+): Map<string, SessionSettingDefinition> => {
+  const map = new Map<string, SessionSettingDefinition>();
+  for (const def of definitions) {
+    map.set(def.key, def);
+  }
+  return map;
+};
+
+const coerceNumber = (value: unknown): number | null => {
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+  if (typeof value === 'string' && value.trim() !== '') {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return null;
+};
+
+const validateNumberValue = (
+  def: z.infer<typeof SessionSettingNumberDefinitionSchema>,
+  value: number,
+): string | null => {
+  if (def.min !== undefined && value < def.min) {
+    return `${def.label} must be at least ${def.min}.`;
+  }
+  if (def.max !== undefined && value > def.max) {
+    return `${def.label} must be at most ${def.max}.`;
+  }
+  return null;
+};
+
+/**
+ * Merge manifest defaults with host-provided overrides. Unknown keys are
+ * ignored; invalid values fall back to defaults.
+ */
+export const resolveSessionSettings = (
+  definitions: readonly SessionSettingDefinition[],
+  overrides: Readonly<Record<string, unknown>> | undefined,
+): ResolvedSessionSettings => {
+  const resolved: Record<string, JsonValue> = {};
+  for (const def of definitions) {
+    const raw = overrides?.[def.key];
+    if (def.type === 'number') {
+      const coerced = raw === undefined ? def.default : coerceNumber(raw);
+      const value =
+        coerced === null
+          ? def.default
+          : validateNumberValue(def, coerced) === null
+            ? coerced
+            : def.default;
+      resolved[def.key] = value;
+      continue;
+    }
+    if (def.type === 'boolean') {
+      resolved[def.key] =
+        typeof raw === 'boolean' ? raw : def.default;
+      continue;
+    }
+    const allowed = new Set(def.options.map((opt) => opt.value));
+    resolved[def.key] =
+      typeof raw === 'string' && allowed.has(raw) ? raw : def.default;
+  }
+  return resolved;
+};
+
+export type SessionSettingsValidationResult =
+  | { readonly ok: true; readonly settings: ResolvedSessionSettings }
+  | { readonly ok: false; readonly message: string };
+
+/**
+ * Strict validation for provision-time overrides. Rejects unknown keys
+ * and out-of-range values.
+ */
+export const validateSessionSettingsOverrides = (
+  definitions: readonly SessionSettingDefinition[],
+  overrides: Readonly<Record<string, unknown>> | undefined,
+): SessionSettingsValidationResult => {
+  if (!overrides || Object.keys(overrides).length === 0) {
+    return {
+      ok: true,
+      settings: resolveSessionSettings(definitions, undefined),
+    };
+  }
+
+  const defs = definitionByKey(definitions);
+  for (const key of Object.keys(overrides)) {
+    if (!defs.has(key)) {
+      return { ok: false, message: `Unknown setting "${key}".` };
+    }
+  }
+
+  for (const def of definitions) {
+    const raw = overrides[def.key];
+    if (raw === undefined) continue;
+
+    if (def.type === 'number') {
+      const coerced = coerceNumber(raw);
+      if (coerced === null) {
+        return { ok: false, message: `${def.label} must be a number.` };
+      }
+      const err = validateNumberValue(def, coerced);
+      if (err) return { ok: false, message: err };
+      continue;
+    }
+
+    if (def.type === 'boolean') {
+      if (typeof raw !== 'boolean') {
+        return { ok: false, message: `${def.label} must be true or false.` };
+      }
+      continue;
+    }
+
+    if (typeof raw !== 'string' || !def.options.some((opt) => opt.value === raw)) {
+      return { ok: false, message: `${def.label} has an invalid option.` };
+    }
+  }
+
+  return {
+    ok: true,
+    settings: resolveSessionSettings(definitions, overrides),
+  };
+};

package/src/validate.test.ts

@@ -104,6 +104,31 @@ describe('validateManifest — structural: initial phase', () => {
   });
 });
 
+describe('validateManifest — structural: abort phase', () => {
+  it('accepts a manifest with no abortPhaseId (optional)', () => {
+    const fixture = cloneFixture();
+    expect(validateManifest(fixture).ok).toBe(true);
+  });
+
+  it('accepts a valid abortPhaseId that references a declared phase', () => {
+    const fixture = cloneFixture();
+    fixture.workflow.abortPhaseId = 'resolved';
+    expect(validateManifest(fixture).ok).toBe(true);
+  });
+
+  it('rejects an abortPhaseId that is not a declared phase', () => {
+    const fixture = cloneFixture();
+    fixture.workflow.abortPhaseId = 'nonexistent';
+    const result = validateManifest(fixture);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expectErrorCode(result.error, 'unknown_abort_phase');
+      const issue = result.error.find((e) => e.code === 'unknown_abort_phase');
+      expect(issue?.path).toEqual(['workflow', 'abortPhaseId']);
+    }
+  });
+});
+
 describe('validateManifest — structural: duplicate phase ids', () => {
   it('rejects a manifest where two phases share an id', () => {
     const fixture = cloneFixture();
@@ -272,6 +297,10 @@ describe('validateManifest — structural: phase side effects (chunk B8c)', () =
 
   it('accepts a phase with valid scoring + inference side effects', () => {
     const fixture = cloneFixture();
+    fixture.promptSlots.callTemplates.host_judge = {
+      prompt: 'Judge answers.',
+      qualityTier: 'standard',
+    };
     patchPhase(fixture, 'guess', {
       sideEffects: [
         {
@@ -282,7 +311,7 @@ describe('validateManifest — structural: phase side effects (chunk B8c)', () =
         },
         {
           kind: 'inference',
-          callKind: 'host_judge',
+          templateId: 'host_judge',
           targetPath: '/session/inference/host_judge',
         },
       ],

package/src/validate.ts

@@ -63,6 +63,7 @@ import type { ManifestPhase } from './phase.js';
 export type ValidationErrorCode =
   | 'schema'
   | 'unknown_initial_phase'
+  | 'unknown_abort_phase'
   | 'duplicate_phase_id'
   | 'unknown_transition_target'
   | 'unreachable_phase'
@@ -70,7 +71,9 @@ export type ValidationErrorCode =
   | 'unknown_opportunity_phase'
   | 'unknown_award_dimension'
   | 'unknown_side_effect_scoring_dimension'
-  | 'unknown_side_effect_persona_binding';
+  | 'unknown_side_effect_persona_binding'
+  | 'unknown_side_effect_inference_template'
+  | 'call_template_tier_not_allowed';
 
 export type ValidationError = {
   readonly code: ValidationErrorCode;
@@ -135,6 +138,21 @@ const checkInitialPhase = (
   }
 };
 
+const checkAbortPhase = (
+  workflow: Workflow,
+  validIds: ReadonlySet<string>,
+  out: ValidationError[],
+): void => {
+  if (workflow.abortPhaseId === undefined) return;
+  if (!validIds.has(workflow.abortPhaseId)) {
+    out.push({
+      code: 'unknown_abort_phase',
+      path: ['workflow', 'abortPhaseId'],
+      message: `abortPhaseId '${workflow.abortPhaseId}' is not declared in workflow.phases`,
+    });
+  }
+};
+
 const checkTransitionTargets = (
   workflow: Workflow,
   validIds: ReadonlySet<string>,
@@ -276,15 +294,16 @@ const checkAwardDimensions = (
  *     dispatch time; catching it at manifest validation surfaces
  *     the error at publish time instead.
  *
- * `state_write` and `inference` side effects have no cross-field
- * dependencies the manifest layer can check — the JSON-Patch ops are
- * validated against per-Experience state schemas at apply time, and
- * `inference.callKind` is enum-pinned at the schema level already.
+ * `state_write` side effects have no cross-field dependencies the
+ * manifest layer can check — the JSON-Patch ops are validated against
+ * per-Experience state schemas at apply time. `inference.templateId`
+ * is cross-checked against `promptSlots.callTemplates`.
  */
 const checkPhaseSideEffects = (
   phases: readonly ManifestPhase[],
   dimensionIds: ReadonlySet<string>,
   personaIds: ReadonlySet<string>,
+  templateIds: ReadonlySet<string>,
   out: ValidationError[],
 ): void => {
   for (let i = 0; i < phases.length; i += 1) {
@@ -323,11 +342,44 @@ const checkPhaseSideEffects = (
             message: `phase '${phase.id}' persona_memory side effect references unbound persona '${effect.personaId}'`,
           });
         }
+      } else if (effect.kind === 'inference') {
+        if (!templateIds.has(effect.templateId)) {
+          out.push({
+            code: 'unknown_side_effect_inference_template',
+            path: [
+              'workflow',
+              'phases',
+              i,
+              'sideEffects',
+              j,
+              'templateId',
+            ],
+            message: `phase '${phase.id}' inference side effect references unknown call template '${effect.templateId}'`,
+          });
+        }
       }
     }
   }
 };
 
+const checkCallTemplateQualityTiers = (
+  manifest: Manifest,
+  out: ValidationError[],
+): void => {
+  const allowed = new Set(manifest.inferenceEnvelope.qualityTiers);
+  for (const [templateId, template] of Object.entries(
+    manifest.promptSlots.callTemplates,
+  )) {
+    if (!allowed.has(template.qualityTier)) {
+      out.push({
+        code: 'call_template_tier_not_allowed',
+        path: ['promptSlots', 'callTemplates', templateId, 'qualityTier'],
+        message: `call template '${templateId}' uses quality tier '${template.qualityTier}' which is not in inferenceEnvelope.qualityTiers`,
+      });
+    }
+  }
+};
+
 // -----------------------------------------------------------------------------
 // Public entrypoint
 // -----------------------------------------------------------------------------
@@ -358,6 +410,7 @@ export const validateManifest = (
 
   const validIds = checkPhaseIdsUnique(manifest.workflow, errors);
   checkInitialPhase(manifest.workflow, validIds, errors);
+  checkAbortPhase(manifest.workflow, validIds, errors);
   checkTransitionTargets(manifest.workflow, validIds, errors);
   checkReachability(manifest.workflow, validIds, errors);
   checkPersonaRolesUnique(manifest.personaBindings, errors);
@@ -377,8 +430,10 @@ export const validateManifest = (
     manifest.workflow.phases,
     dimensionIds,
     personaIds,
+    new Set(Object.keys(manifest.promptSlots.callTemplates)),
     errors,
   );
+  checkCallTemplateQualityTiers(manifest, errors);
 
   if (errors.length > 0) return err(errors);
   return ok(manifest);