@telorun/analyzer 0.47.0 → 0.49.0

package/dist/analysis-registry.d.ts

@@ -62,20 +62,25 @@ export declare class AnalysisRegistry {
      *  unresolvable. */
     capabilityForRef(xTeloRef: string): string | undefined;
     /** Resolves the JSON Schema for a kind's `invoke()` inputs, for editor hosts
-     *  that render a typed inputs form. Two-layer fallback mirroring the analyzer's
-     *  template inputs typing: the definition's own `inputType`, then the
-     *  `extends`-declared abstract's `inputType`. Resolves the inline
-     *  (`{ kind: Type.JsonSchema, schema }`) and raw-schema forms; a bare named
-     *  type reference is left unresolved (returns undefined) so the caller can fall
-     *  back to a freeform map. Undefined when the kind declares no input contract. */
+     *  that render a typed inputs form. A thin wrapper over the shared contract
+     *  resolver, so the form an editor renders is the contract `telo check` and the
+     *  kernel enforce — nearest declaration along `extends`, replacing rather than
+     *  merging. A bare named type reference is left unresolved (returns undefined,
+     *  no manifests are in scope here) so the caller can fall back to a freeform
+     *  map. Undefined when the kind declares no input contract. */
     inputTypeForKind(kind: string): Record<string, unknown> | undefined;
-    /** Resolves the JSON Schema for a kind's `invoke()` / `run()` output, for
+    /** Resolves the JSON Schema for a kind's `invoke()` / `provide()` output, for
      *  editor hosts that render a typed output signature. Mirrors
-     *  {@link inputTypeForKind}: the definition's own `outputType`, then the
-     *  `extends`-declared abstract's `outputType`. Resolves the inline and
-     *  raw-schema forms; a bare named type reference is left unresolved. Undefined
-     *  when the kind declares no output contract. */
+     *  {@link inputTypeForKind}. Undefined when the kind declares no output
+     *  contract. */
     outputTypeForKind(kind: string): Record<string, unknown> | undefined;
+    private contractForKind;
+    /** A resolver that re-scopes at every hop of an `extends` chain: each kind is
+     *  resolved in the module that DECLARED the definition it was read off, since
+     *  `extends` aliases are lexical. `resolveParent` always passes that definition
+     *  as `from`, so one resolver serves a chain of any depth crossing any number
+     *  of modules. */
+    private scopedDefResolver;
     private capabilitiesForRefs;
     /**
      * Walks a manifest's annotation sites (refs, scopes, schema-from, CEL) via
@@ -96,6 +101,12 @@ export declare class AnalysisRegistry {
      */
     builtinDefinitions(): ResourceDefinition[];
     resolveDefinition(kind: string): ResourceDefinition | undefined;
+    /** Resolve a kind in a named module's scope. The entry point for walking an
+     *  `extends` chain from outside it (the kernel's contract binding): aliases are
+     *  lexical, so each hop must resolve in the module that declared the definition
+     *  the kind was read off. Falls back to the global table when the module is
+     *  unknown or is a root. */
+    resolveDefinitionIn(kind: string, module?: string): ResourceDefinition | undefined;
     /** A resolver scoped to `def`'s OWN module, for resolving that definition's
      *  `extends` target.
      *

package/dist/analysis-registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"analysis-registry.d.ts","sourceRoot":"","sources":["../src/analysis-registry.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"analysis-registry.d.ts","sourceRoot":"","sources":["../src/analysis-registry.ts"],"names":[],"mappings":"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"}

package/dist/analysis-registry.js

@@ -3,8 +3,8 @@ import { KERNEL_BUILTINS } from "./builtins.js";
 import { DefinitionRegistry } from "./definition-registry.js";
 import { computeSuggestKind, computeValidUserFacingKinds } from "./kind-suggest.js";
 import { visitManifest as runVisitManifest } from "./manifest-visitor.js";
+import { resolveContract } from "./invocation-contract.js";
 import { isRefEntry, isScopeEntry } from "./reference-field-map.js";
-import { resolveTypeFieldToSchema } from "./validate-cel-context.js";
 /**
  * Accumulates type and alias knowledge for a running kernel or analysis session.
  * Wraps AliasResolver and DefinitionRegistry into a single domain-level interface
@@ -96,51 +96,38 @@ export class AnalysisRegistry {
         return def.capability ?? kind;
     }
     /** Resolves the JSON Schema for a kind's `invoke()` inputs, for editor hosts
-     *  that render a typed inputs form. Two-layer fallback mirroring the analyzer's
-     *  template inputs typing: the definition's own `inputType`, then the
-     *  `extends`-declared abstract's `inputType`. Resolves the inline
-     *  (`{ kind: Type.JsonSchema, schema }`) and raw-schema forms; a bare named
-     *  type reference is left unresolved (returns undefined) so the caller can fall
-     *  back to a freeform map. Undefined when the kind declares no input contract. */
+     *  that render a typed inputs form. A thin wrapper over the shared contract
+     *  resolver, so the form an editor renders is the contract `telo check` and the
+     *  kernel enforce — nearest declaration along `extends`, replacing rather than
+     *  merging. A bare named type reference is left unresolved (returns undefined,
+     *  no manifests are in scope here) so the caller can fall back to a freeform
+     *  map. Undefined when the kind declares no input contract. */
     inputTypeForKind(kind) {
-        const def = this.resolveDefinition(kind);
-        if (!def)
-            return undefined;
-        const own = resolveTypeFieldToSchema(def.inputType, []);
-        if (own)
-            return own;
-        if (def.extends) {
-            const abstractDef = this.resolveDefinition(def.extends);
-            if (abstractDef) {
-                const inherited = resolveTypeFieldToSchema(abstractDef.inputType, []);
-                if (inherited)
-                    return inherited;
-            }
-        }
-        return undefined;
+        return this.contractForKind(kind, "inputType");
     }
-    /** Resolves the JSON Schema for a kind's `invoke()` / `run()` output, for
+    /** Resolves the JSON Schema for a kind's `invoke()` / `provide()` output, for
      *  editor hosts that render a typed output signature. Mirrors
-     *  {@link inputTypeForKind}: the definition's own `outputType`, then the
-     *  `extends`-declared abstract's `outputType`. Resolves the inline and
-     *  raw-schema forms; a bare named type reference is left unresolved. Undefined
-     *  when the kind declares no output contract. */
+     *  {@link inputTypeForKind}. Undefined when the kind declares no output
+     *  contract. */
     outputTypeForKind(kind) {
+        return this.contractForKind(kind, "outputType");
+    }
+    contractForKind(kind, direction) {
         const def = this.resolveDefinition(kind);
         if (!def)
             return undefined;
-        const own = resolveTypeFieldToSchema(def.outputType, []);
-        if (own)
-            return own;
-        if (def.extends) {
-            const abstractDef = this.resolveDefinition(def.extends);
-            if (abstractDef) {
-                const inherited = resolveTypeFieldToSchema(abstractDef.outputType, []);
-                if (inherited)
-                    return inherited;
-            }
-        }
-        return undefined;
+        return resolveContract(direction, undefined, def, {
+            resolveDefinition: this.scopedDefResolver(),
+            typeManifestsFor: () => [],
+        })?.schema;
+    }
+    /** A resolver that re-scopes at every hop of an `extends` chain: each kind is
+     *  resolved in the module that DECLARED the definition it was read off, since
+     *  `extends` aliases are lexical. `resolveParent` always passes that definition
+     *  as `from`, so one resolver serves a chain of any depth crossing any number
+     *  of modules. */
+    scopedDefResolver() {
+        return (kind, from) => this.resolveDefinitionIn(kind, from?.metadata?.module);
     }
     capabilitiesForRefs(refs) {
         const out = [];
@@ -178,6 +165,16 @@ export class AnalysisRegistry {
         const resolved = ctx.aliases?.resolveKind(kind);
         return ctx.definitions?.resolve(kind) ?? (resolved ? ctx.definitions?.resolve(resolved) : undefined);
     }
+    /** Resolve a kind in a named module's scope. The entry point for walking an
+     *  `extends` chain from outside it (the kernel's contract binding): aliases are
+     *  lexical, so each hop must resolve in the module that declared the definition
+     *  the kind was read off. Falls back to the global table when the module is
+     *  unknown or is a root. */
+    resolveDefinitionIn(kind, module) {
+        const scope = (module ? this.aliasesByModule.get(module) : undefined) ?? this.aliases;
+        const canonical = scope.resolveKind(kind);
+        return this.defs.resolve(kind) ?? (canonical ? this.defs.resolve(canonical) : undefined);
+    }
     /** A resolver scoped to `def`'s OWN module, for resolving that definition's
      *  `extends` target.
      *

package/dist/analyzer.d.ts

@@ -1,7 +1,44 @@
-import type { ResourceManifest } from "@telorun/sdk";
+import type { ResourceDefinition, ResourceManifest } from "@telorun/sdk";
+import { AliasResolver, type ModuleScopes } from "./alias-resolver.js";
 import { AnalysisRegistry } from "./analysis-registry.js";
 import { type CelHandlers } from "./cel-environment.js";
+import { DefinitionRegistry } from "./definition-registry.js";
+import { type ContractScope } from "./invocation-contract.js";
 import { type AnalysisDiagnostic, type AnalysisOptions } from "./types.js";
+/** The {@link ContractScope} the analyzer resolves invocation contracts in: kinds
+ *  resolve in the module that declared the definition they were read off (so an
+ *  `extends` chain crossing module boundaries re-scopes at every hop), and named
+ *  `telo#Type` references resolve against the flattened manifest list. `resolveIn`
+ *  is the top-level entry point, where the kind was written by the READING
+ *  module and there is no declaring definition yet. */
+export declare function analyzerContractScope(defs: DefinitionRegistry, aliases: AliasResolver, scopes: ModuleScopes, allManifests: Record<string, any>[]): ContractScope & {
+    resolveIn(kind: string, module?: string): ResourceDefinition | undefined;
+};
+/** True when an issue reports a property that is absent — its path points at a
+ *  node the manifest does not contain. */
+export declare const missingRequired: (issue: {
+    message: string;
+}) => boolean;
+/** The path minus its last segment: the node that should have contained the
+ *  missing property. Empty for a top-level miss, which anchors on the map. */
+export declare function containerOf(path: string): string;
+/** Resolve a local `$ref` (only `#/$defs/<name>` form) against the root schema.
+ *  Non-refs and unresolved refs pass through unchanged. */
+export declare function resolveLocalRef(schema: Record<string, any> | undefined, root: Record<string, any>): Record<string, any> | undefined;
+/** Gather property schemas from a (possibly variant-bearing) object schema:
+ *  top-level `properties` plus every `oneOf` / `anyOf` / `allOf` branch. */
+export declare function gatherPropertySchemas(schema: Record<string, any>): Array<[string, Record<string, any>]>;
+/**
+ * Generic, role-driven walk over an `x-telo-step-context` step array. Calls
+ * `visit(step, stepPath)` for every step — top-level and nested through the
+ * `x-telo-topology-role` forms (`branch`, `branch-list`, `case-map`). This is
+ * the single definition of how steps nest, shared by `buildStepContextSchema`
+ * (which types `steps.<name>.result`) and `validateStepInvokeReferences` (which
+ * checks invoke refs), so the topology contract lives in one place — adding a
+ * role or nesting form updates both consumers at once. No resource kind is
+ * hardcoded; recursion is driven entirely by the schema annotations.
+ */
+export declare function walkStepArray(steps: unknown[], stepItemSchema: Record<string, any> | undefined, rootSchema: Record<string, any>, basePath: string, visit: (step: Record<string, any>, stepPath: string) => void): void;
 export interface StaticAnalyzerOptions {
     celHandlers?: CelHandlers;
 }

package/dist/analyzer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../src/analyzer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAsB,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAKzE,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAIL,KAAK,WAAW,EACjB,MAAM,sBAAsB,CAAC;AA6B9B,OAAO,EAAsB,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AAyyB/F,MAAM,WAAW,qBAAqB;IACpC,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;gBAEzB,OAAO,GAAE,qBAA0B;IAI/C;;;;;;;;;;;;;;OAcG;IACH,OAAO,CACL,SAAS,EAAE,gBAAgB,EAAE,EAC7B,OAAO,CAAC,EAAE,eAAe,EACzB,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,kBAAkB,EAAE;IA4hCvB,aAAa,CACX,SAAS,EAAE,gBAAgB,EAAE,EAC7B,OAAO,CAAC,EAAE,eAAe,EACzB,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,kBAAkB,EAAE;IAMvB,SAAS,CACP,SAAS,EAAE,gBAAgB,EAAE,EAC7B,QAAQ,EAAE,gBAAgB,EAI1B,kBAAkB,CAAC,EAAE,gBAAgB,EAAE,GACtC,gBAAgB,EAAE;IAyBrB,OAAO,CACL,SAAS,EAAE,gBAAgB,EAAE,EAC7B,QAAQ,EAAE,gBAAgB,GACzB;QAAE,WAAW,EAAE,kBAAkB,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;QAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE;CAsB5F"}
+{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../src/analyzer.ts"],"names":[],"mappings":"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"}

package/dist/analyzer.js

@@ -1,9 +1,10 @@
 import { canonicalTypeSchemaId, OBSERVED_STATE_KEY } from "@telorun/sdk";
 import { defaultRegistry, isRefSentinel, isTaggedSentinel } from "@telorun/templating";
-import { AliasResolver, scopeResolverForModule } from "./alias-resolver.js";
+import { AliasResolver, moduleScopedDefResolver, scopeResolverForModule, } from "./alias-resolver.js";
 import { buildCelEnvironment, buildImportInputCelEnvironment, buildTypedCelEnvironment, } from "./cel-environment.js";
 import { DefinitionRegistry } from "./definition-registry.js";
 import { effectiveAuthorSchema } from "./extends-resolution.js";
+import { PERMISSIVE_CONTRACT, resolveContract, } from "./invocation-contract.js";
 import { buildDependencyGraph, formatCycle } from "./dependency-graph.js";
 import { buildKernelGlobalsSchema, mergeKernelGlobalsIntoContext } from "./kernel-globals.js";
 import { buildObservedStateIndex, buildObservedStateResourcesSchema, collectRunReachableNames, observedStateRead, validateObservedStateDeclarations, } from "./validate-observed-state.js";
@@ -20,11 +21,14 @@ import { rewriteSyntheticOrigins } from "./rewrite-synthetic-origins.js";
 import { celTypeSatisfiesJsonSchema, substituteCelFields, validateAgainstSchema, } from "./schema-compat.js";
 import { collectValueSchemaIssues } from "./validate-value-schema.js";
 import { DiagnosticSeverity } from "./types.js";
-import { extractAccessChains, extractCelRegionScopes, extractContextsFromSchema, getManifestItem, pathMatchesScope, resolveContextAnnotations, resolveTypeFieldToSchema, } from "./validate-cel-context.js";
+import { extractAccessChains, extractCelRegionScopes, extractContextsFromSchema, getManifestItem, pathMatchesScope, resolveContextAnnotations, } from "./validate-cel-context.js";
 import { buildEvalPaths, evalPathsCover } from "./eval-paths.js";
 import { validateExtends } from "./validate-extends.js";
 import { validateLogging } from "./validate-logging.js";
+import { validateModuleArtifact } from "./validate-module-artifact.js";
 import { validateBaseMapping } from "./validate-base-mapping.js";
+import { validateInvocationContract } from "./validate-invocation-contract.js";
+import { collectStepInputIssues } from "./validate-step-inputs.js";
 import { validateNestedInlineResources } from "./validate-nested-inline.js";
 import { validateProviderCoherence } from "./validate-provider-coherence.js";
 import { validateReferences } from "./validate-references.js";
@@ -74,17 +78,19 @@ function resolveSelfOrAlias(value, ownModule, scopeResolver) {
     }
     return scopeResolver.resolveKind(value);
 }
-/** Look up a top-level field (`outputType`, `inputType`) on a kind's
- *  `Telo.Definition`. Used as a fallback by `buildStepContextSchema` when the
- *  invoked resource manifest doesn't carry the field inline — most kinds
- *  declare result shape on the definition, not the resource. */
-function lookupDefinitionTypeField(invokedKind, fieldName, defs, aliases, allManifests) {
-    const canonical = aliases.resolveKind(invokedKind) ?? invokedKind;
-    const def = defs.resolve(canonical);
-    if (!def)
-        return undefined;
-    const value = def[fieldName];
-    return resolveTypeFieldToSchema(value, allManifests);
+/** The {@link ContractScope} the analyzer resolves invocation contracts in: kinds
+ *  resolve in the module that declared the definition they were read off (so an
+ *  `extends` chain crossing module boundaries re-scopes at every hop), and named
+ *  `telo#Type` references resolve against the flattened manifest list. `resolveIn`
+ *  is the top-level entry point, where the kind was written by the READING
+ *  module and there is no declaring definition yet. */
+export function analyzerContractScope(defs, aliases, scopes, allManifests) {
+    const resolve = moduleScopedDefResolver(defs, aliases, scopes);
+    return {
+        resolveDefinition: resolve,
+        resolveIn: resolve.in,
+        typeManifestsFor: () => allManifests,
+    };
 }
 const SOURCE = "telo-analyzer";
 /** Build a closed JSON Schema for the `self` CEL variable available inside a
@@ -118,50 +124,66 @@ function buildSelfSchema(definition, defs, aliases) {
     };
 }
 /** Build the JSON Schema for the `inputs` CEL variable available inside an
- *  invocable template body. Three-layer fallback mirroring the runtime's
- *  caller-supplied inputs:
- *    1. The definition's own `inputType:` field (preferred).
- *    2. The `extends:`-declared abstract's `inputType:` (so a concrete
- *       definition inheriting a contract gets typed inputs without
- *       redeclaring them).
- *    3. Undefined — caller signals opaque `map<string, dyn>` upstream. */
-function lookupTemplateInputsSchema(definition, defs, aliases, allManifests) {
-    const own = resolveTypeFieldToSchema(definition.inputType, allManifests);
-    if (own)
-        return own;
-    const ext = definition.extends;
-    if (typeof ext === "string" && ext.length > 0) {
-        const canonical = aliases.resolveKind(ext) ?? ext;
-        const abstractDef = defs.resolve(canonical);
-        if (abstractDef) {
-            const inherited = resolveTypeFieldToSchema(abstractDef.inputType, allManifests);
-            if (inherited)
-                return inherited;
-        }
-    }
-    return undefined;
+ *  invocable template body — the shared contract resolver applied to the
+ *  definition itself, so a body is typed against the exact signature callers are
+ *  checked against and dispatch enforces. Walks the whole `extends` chain rather
+ *  than one hop, so a definition two levels below the declaration still gets
+ *  typed inputs. Undefined when nothing in the chain declares a contract —
+ *  the caller signals opaque `map<string, dyn>` upstream. */
+function lookupTemplateInputsSchema(definition, defs, aliases, allManifests, scopes) {
+    return resolveContract("inputType", undefined, definition, analyzerContractScope(defs, aliases, scopes, allManifests))?.schema;
 }
 /** Returns a "resolver-facing" view of the manifest where the fields used as
  *  navigation roots by Telo.Definition's `x-telo-context-from-root` annotations
  *  have been pre-augmented:
  *    - `schema`     → augmented `self` schema (synthetic `name`/`kind`/metadata).
- *    - `inputType`  → resolved with extends fallback when the field isn't
- *                     declared directly on the definition.
+ *    - `inputType`  → resolved through the shared contract resolver, so
+ *                     `x-telo-context-from-root: inputType` substitutes the
+ *                     real signature. Without it the annotation would replace
+ *                     the node verbatim with the inline `{kind, schema}` wrapper
+ *                     the standard library writes everywhere, typing `inputs` as
+ *                     `{kind, schema}` instead of the declared properties.
  *
  *  For non-definition manifests the original object is returned. */
-function manifestRootForResolver(m, defs, aliases, allManifests) {
+function manifestRootForResolver(m, defs, aliases, allManifests, scopes) {
     if (m.kind !== "Telo.Definition")
         return m;
-    const inputs = lookupTemplateInputsSchema(m, defs, aliases, allManifests);
+    const inputs = lookupTemplateInputsSchema(m, defs, aliases, allManifests, scopes);
     return {
         ...m,
         schema: buildSelfSchema(m, defs, aliases),
         ...(inputs ? { inputType: inputs } : {}),
     };
 }
+/** True when an issue reports a property that is absent — its path points at a
+ *  node the manifest does not contain. */
+export const missingRequired = (issue) => /is missing required property/.test(issue.message);
+/** The path minus its last segment: the node that should have contained the
+ *  missing property. Empty for a top-level miss, which anchors on the map. */
+export function containerOf(path) {
+    const dot = path.lastIndexOf(".");
+    return dot === -1 ? "" : path.slice(0, dot);
+}
+/** How to name the owner of a resolved contract in a diagnostic. When the
+ *  contract came from the definition's direct parent, echo the author's own
+ *  spelling (`extends: Mcp.SessionProvider`) — that is the text they can find in
+ *  their file. A contract inherited from further up the chain isn't written
+ *  anywhere in this file, so the canonical `module.Kind` is what locates it. */
+function contractOwnerLabel(definition, contract) {
+    const declaredBy = contract.declaredBy;
+    if (!declaredBy || declaredBy === definition) {
+        return String(definition.metadata?.name ?? definition.kind);
+    }
+    const parentSpelling = definition.extends;
+    const canonical = `${declaredBy.metadata.module}.${declaredBy.metadata.name}`;
+    if (typeof parentSpelling === "string" && parentSpelling.endsWith(`.${declaredBy.metadata.name}`)) {
+        return parentSpelling;
+    }
+    return canonical;
+}
 /** Resolve a local `$ref` (only `#/$defs/<name>` form) against the root schema.
  *  Non-refs and unresolved refs pass through unchanged. */
-function resolveLocalRef(schema, root) {
+export function resolveLocalRef(schema, root) {
     if (!schema)
         return undefined;
     const ref = schema.$ref;
@@ -175,7 +197,7 @@ function resolveLocalRef(schema, root) {
 }
 /** Gather property schemas from a (possibly variant-bearing) object schema:
  *  top-level `properties` plus every `oneOf` / `anyOf` / `allOf` branch. */
-function gatherPropertySchemas(schema) {
+export function gatherPropertySchemas(schema) {
     const out = [];
     if (schema.properties && typeof schema.properties === "object") {
         for (const [k, v] of Object.entries(schema.properties)) {
@@ -206,7 +228,7 @@ function gatherPropertySchemas(schema) {
  * role or nesting form updates both consumers at once. No resource kind is
  * hardcoded; recursion is driven entirely by the schema annotations.
  */
-function walkStepArray(steps, stepItemSchema, rootSchema, basePath, visit) {
+export function walkStepArray(steps, stepItemSchema, rootSchema, basePath, visit) {
     const dispatchRole = (data, role, itemsSchema, path) => {
         if (role === "branch" && Array.isArray(data)) {
             walkStepArray(data, stepItemSchema, rootSchema, path, visit);
@@ -251,20 +273,18 @@ function walkStepArray(steps, stepItemSchema, rootSchema, basePath, visit) {
 }
 /**
  * Build a `steps` context schema from `x-telo-step-context` annotation.
- * Walks each step in the manifest array, resolves the invoked resource's outputType,
- * and builds `steps.<name>.result` context entries.
+ * Walks each step in the manifest array, resolves the invoked resource's output
+ * contract, and builds `steps.<name>.result` context entries.
  *
- * outputType resolution falls through three layers:
- *   1. The invoked resource manifest's own `outputType` field (rare — most
- *      resources don't declare outputType inline).
- *   2. The kind's `Telo.Definition` outputType (the common case for kinds that
- *      declare a stable result shape, e.g. `Ai.TextStream` ↦ `{output: stream}`).
- *   3. Permissive `{type: object, additionalProperties: true}` if neither
- *      yields a schema.
+ * Resolution is the shared {@link resolveContract} — the invoked resource
+ * manifest's own declaration, then the kind's, resolved to the nearest
+ * declaration along `extends`, then permissive. Sharing it with the kernel is
+ * what stops `telo check` from typing `steps.X.result` against one contract
+ * while dispatch validates against another.
  *
- * Layer 2 is what makes `x-telo-stream` properties on definitions actually
- * govern step-result chain validation — without it, the validator falls back
- * to permissive and the stream-opacity rule never fires.
+ * The kind layer is what makes `x-telo-stream` properties on definitions
+ * actually govern step-result chain validation — without it, the validator falls
+ * back to permissive and the stream-opacity rule never fires.
  *
  * Recursion into nested step arrays is annotation-driven via
  * `x-telo-topology-role`. The analyzer recognises three role values:
@@ -275,10 +295,12 @@ function walkStepArray(steps, stepItemSchema, rootSchema, basePath, visit) {
  * No specific Run.Sequence field name is hardcoded; any kind that uses
  * `x-telo-step-context` and tags its branch fields with these roles works.
  */
-function buildStepContextSchema(manifest, defSchema, allManifests, defs, aliases) {
+function buildStepContextSchema(manifest, defSchema, allManifests, defs, aliases, scopes) {
     const props = defSchema.properties;
     if (!props)
         return undefined;
+    const contractScope = analyzerContractScope(defs, aliases, scopes, allManifests);
+    const readingModule = manifest.metadata?.module;
     for (const [fieldName, fieldSchema] of Object.entries(props)) {
         const stepCtx = fieldSchema["x-telo-step-context"];
         if (!stepCtx)
@@ -301,28 +323,22 @@ function buildStepContextSchema(manifest, defSchema, allManifests, defs, aliases
             // or unknown step references slip through chain validation.
             if (typeof name !== "string" || !invoke || typeof invoke !== "object")
                 return;
-            let outputSchema;
             const invokedKind = invoke.kind;
             const invokedName = invoke.name;
-            if (invokedName) {
-                const invokedManifest = allManifests.find((m) => m.metadata?.name === invokedName &&
-                    (!invokedKind || m.kind === invokedKind));
-                if (invokedManifest) {
-                    outputSchema = resolveTypeFieldToSchema(invokedManifest[outputTypeField], allManifests);
-                }
-            }
-            else {
-                outputSchema = resolveTypeFieldToSchema(invoke[outputTypeField], allManifests);
-            }
-            // Fallback: pull outputType from the kind's Telo.Definition. The
-            // resource manifest typically doesn't carry outputType; the def does.
-            if (!outputSchema && invokedKind) {
-                outputSchema = lookupDefinitionTypeField(invokedKind, outputTypeField, defs, aliases, allManifests);
-            }
+            // A named `!ref` carries the target's own manifest (which may narrow the
+            // contract for this one instance); an inline `{ kind, ... }` step IS the
+            // manifest. Either way the kind layer resolves through `extends`.
+            const invokedManifest = invokedName
+                ? allManifests.find((m) => m.metadata?.name === invokedName && (!invokedKind || m.kind === invokedKind))
+                : invoke;
+            const invokedDef = invokedKind
+                ? contractScope.resolveIn(invokedKind, readingModule)
+                : undefined;
+            const outputSchema = resolveContract(outputTypeField, invokedManifest, invokedDef, contractScope)?.schema;
             stepProperties[name] = {
                 type: "object",
                 properties: {
-                    result: outputSchema ?? { type: "object", additionalProperties: true },
+                    result: outputSchema ?? PERMISSIVE_CONTRACT,
                 },
             };
         });
@@ -1015,6 +1031,11 @@ export class StaticAnalyzer {
             // §14.1 / §10.3: redaction paths and `on_full: block` are statically
             // detectable, so they fail `telo check` rather than only at boot.
             diagnostics.push(...validateLogging(allManifests, defs, aliases, aliasesByModule));
+            // Module-artifact surface: bundled-controller selector qualifiers and the
+            // published `layers:` index. Every case is decidable from the manifest and
+            // would otherwise fail on a consumer's machine — or, for a mistyped platform
+            // axis, silently offer one platform's binary to every host.
+            diagnostics.push(...validateModuleArtifact(allManifests));
         }
         resolveSchemaTypeRefs(allManifests, aliases, aliasesByModule);
         // Trusted-input fast path: when the caller has already attested that
@@ -1312,6 +1333,7 @@ export class StaticAnalyzer {
         // the abstract this definition `extends`. CEL fields inside the templated
         // values are replaced with type-appropriate placeholders before AJV runs —
         // same pattern as the per-resource schema validation above.
+        const contractScope = analyzerContractScope(defs, aliases, { aliasesByModule, rootModules }, allManifests);
         for (const m of allManifests) {
             if (m.kind !== "Telo.Definition")
                 continue;
@@ -1354,25 +1376,23 @@ export class StaticAnalyzer {
             // values passed to the dispatch target's invoke(). Validate against the
             // target's declared `inputType` when both sides have one.
             if (dispatchKind && md.inputs && typeof md.inputs === "object") {
-                const targetSchema = lookupDefinitionTypeField(dispatchKind, "inputType", defs, aliases, allManifests);
+                const targetSchema = resolveContract("inputType", undefined, contractScope.resolveIn(dispatchKind, md.metadata?.module), contractScope)?.schema;
                 if (targetSchema) {
                     emitTargetMismatch(dispatchKind, targetSchema, md.inputs, "inputs");
                 }
             }
-            // Top-level `result:` is a post-call mapping that must satisfy the abstract
-            // this definition `extends` (`outputType`). It's a sibling of whichever
+            // Top-level `result:` is a post-call mapping that must satisfy THIS
+            // definition's output contract — its own `outputType` when it declares
+            // one, otherwise the nearest ancestor's. It's a sibling of whichever
             // dispatch entry-point declared a kind-typed target (`provide:` or
             // `invoke:`). The target's outputType lives on the dispatcher's `kind`
             // and is what `result` is typed against *inside* CEL — separate role.
             const hasDispatchObject = (provide && typeof provide === "object" && !Array.isArray(provide)) ||
                 (invoke && typeof invoke === "object" && !Array.isArray(invoke));
             if (hasDispatchObject && md.result && typeof md.result === "object") {
-                const extendsValue = md.extends;
-                if (typeof extendsValue === "string" && extendsValue.length > 0) {
-                    const abstractSchema = lookupDefinitionTypeField(extendsValue, "outputType", defs, aliases, allManifests);
-                    if (abstractSchema) {
-                        emitTargetMismatch(extendsValue, abstractSchema, md.result, "result");
-                    }
+                const contract = resolveContract("outputType", undefined, md, contractScope);
+                if (contract) {
+                    emitTargetMismatch(contractOwnerLabel(md, contract), contract.schema, md.result, "result");
                 }
             }
         }
@@ -1404,8 +1424,25 @@ export class StaticAnalyzer {
                 const m = e.source;
                 celInvocationContext = m.metadata?.xTeloInvocationContext;
                 celStepContextSchema = e.definition?.schema
-                    ? buildStepContextSchema(m, e.definition.schema, allManifests, defs, aliases)
+                    ? buildStepContextSchema(m, e.definition.schema, allManifests, defs, aliases, { aliasesByModule, rootModules })
                     : undefined;
+                if (e.definition?.schema) {
+                    const stepName = m.metadata?.name;
+                    const stepFile = m.metadata?.source;
+                    for (const issue of collectStepInputIssues(m, e.definition.schema, allManifests, defs, aliases, { aliasesByModule, rootModules })) {
+                        diagnostics.push({
+                            severity: DiagnosticSeverity.Error,
+                            code: "CONTRACT_INPUTS_MISMATCH",
+                            source: SOURCE,
+                            message: `${m.kind}/${stepName}: inputs at '${issue.path}' do not satisfy ${issue.targetLabel}'s declared inputType: ${issue.message}`,
+                            data: {
+                                resource: { kind: m.kind, name: stepName ?? "" },
+                                filePath: stepFile,
+                                path: issue.path,
+                            },
+                        });
+                    }
+                }
                 celErrorScopes = collectErrorContextScopes(e.definition?.schema);
                 // The non-eval-field check only applies to runtime resource instances:
                 // structural / templating kinds (capability `Telo.Template`, or no
@@ -1521,7 +1558,7 @@ export class StaticAnalyzer {
                     const manifestItem = matchedScope
                         ? getManifestItem(path, matchedScope, m)
                         : m;
-                    const rootForResolver = manifestRootForResolver(m, defs, aliases, allManifests);
+                    const rootForResolver = manifestRootForResolver(m, defs, aliases, allManifests, { aliasesByModule, rootModules });
                     const resolvedContext = resolveContextAnnotations(matchedContext, manifestItem, {
                         manifestRoot: rootForResolver,
                         defs,
@@ -1619,6 +1656,7 @@ export class StaticAnalyzer {
         // Validate `extends` fields and flag legacy `capability: <UserAbstract>` overload.
         diagnostics.push(...validateExtends(allManifests, defs, aliases));
         diagnostics.push(...validateBaseMapping(allManifests, defs, aliases));
+        diagnostics.push(...validateInvocationContract(allManifests, defs, aliases, aliasesByModule));
         // Validate provider coherence rules for `provide:` template-target definitions.
         diagnostics.push(...validateProviderCoherence(allManifests, defs, aliases));
         // Validate throws: declarations and catches: coverage (rules 1, 2, 4, 7)